Convert Doubly Linked List to Array I - Practice Coding Problems

Convert Doubly Linked List to Array I - Problem

You are given the head of a doubly linked list, where each node contains an integer value and has both next and prev pointers. Your task is to traverse this doubly linked list and convert it into a regular integer array.

A doubly linked list is a data structure where each node points to both the next node and the previous node in the sequence. This allows for efficient bidirectional traversal, but for this problem, you'll only need to traverse in one direction.

Goal: Return an integer array containing all the values from the doubly linked list in the same order they appear when traversing from head to tail.

Example:
If your doubly linked list looks like: 1 ⇄ 2 ⇄ 3 ⇄ null
Then your output array should be: [1, 2, 3]

Input & Output

example_1.py — Basic Case

$ Input: head = [1,2,3,4,5]

› Output: [1,2,3,4,5]

💡 Note: The doubly linked list 1⇄2⇄3⇄4⇄5 is converted to array [1,2,3,4,5] by traversing from head to tail.

example_2.py — Single Node

$ Input: head = [42]

› Output: [42]

💡 Note: A doubly linked list with only one node containing value 42 becomes an array with one element [42].

example_3.py — Empty List

$ Input: head = []

› Output: []

💡 Note: An empty doubly linked list (head = null) results in an empty array [].

Constraints

The number of nodes in the list is in the range [0, 1000]
Node values are in the range [-1000, 1000]
Follow up: Can you solve it using only one pass through the linked list?

Visualization

Tap to expand

Understanding the Visualization

Start at Head

Position yourself at the first node of the doubly linked list

Collect Value

Add the current node's value to your result array

Move Forward

Follow the 'next' pointer to advance to the next node

Repeat Until End

Continue steps 2-3 until you reach a null pointer

Return Result

Your array now contains all values in the original order

Key Takeaway

🎯 Key Insight: Converting a doubly linked list to an array is simply a matter of forward traversal - we don't need the backward pointers, just follow the 'next' pointers and collect values in order.

Asked in

a Amazon 45 ⊞ Microsoft 32 G Google 28 f Meta 15

The optimal solution uses a single-pass traversal approach. Simply iterate through the doubly linked list from head to tail using the next pointers, collecting each node's value into a dynamic array. This achieves O(n) time complexity with only one traversal, making it both time and code efficient. The key insight is that we don't need the prev pointers or multiple passes - a straightforward forward traversal is sufficient.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Dynamic Array (Optimal)	O(n)	O(n)	Traverse once and dynamically build the result array
Two-Pass Approach (Count then Collect)	O(n)	O(n)	First count nodes, then allocate array and collect values

One-Pass Dynamic Array (Optimal) — Algorithm Steps

Initialize an empty dynamic array/list
Start from the head of the doubly linked list
For each node, append its value to the result array
Move to the next node using the 'next' pointer
Continue until we reach the end (null)
Return the completed array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty array and pointer at head

Process Node

Add current node's value to array

Move Forward

Advance to next node

Repeat

Continue until reaching end

Code -

solution.c — C

int* doublyLinkedListToArray(struct ListNode* head, int* returnSize) {
    *returnSize = 0;
    if (!head) return NULL;
    
    // Count nodes first (C doesn't have dynamic arrays)
    int count = 0;
    struct ListNode* temp = head;
    while (temp) {
        count++;
        temp = temp->next;
    }
    
    int* result = (int*)malloc(count * sizeof(int));
    *returnSize = count;
    
    struct ListNode* current = head;
    int i = 0;
    while (current) {
        result[i++] = current->val;
        current = current->next;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n nodes in the linked list

✓ Linear Growth

Space Complexity

O(n)

Space needed for the output array containing n elements

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~8 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Dynamic Array (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler