Convert Doubly Linked List to Array II - Practice Coding Problems

Convert Doubly Linked List to Array II - Problem

You are dropped into the middle of a doubly linked list adventure! 🚀

Given an arbitrary node from a doubly linked list (could be anywhere - beginning, middle, or end), your mission is to reconstruct the entire linked list and return it as an integer array in the correct order.

Each node in this doubly linked list has:

val: The integer value stored in the node
next: Pointer to the next node (or null if it's the tail)
prev: Pointer to the previous node (or null if it's the head)

The challenge is that you don't know where you are in the list! You need to navigate both directions to find the complete sequence and return the elements in their natural order from head to tail.

Goal: Return an integer array containing all elements of the doubly linked list in order from head to tail.

Input & Output

example_1.py — Basic case starting from middle

$ Input: node = ListNode(2) # Given node in middle of [1,2,3,4]

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

💡 Note: Starting from node with value 2, we navigate backward to find head (1), then traverse forward to collect all values [1,2,3,4]

example_2.py — Starting from head

$ Input: node = ListNode(1) # Given node is the head of [1,2,3]

› Output: [1, 2, 3]

💡 Note: Starting from the head node, we don't need to move backward. We simply traverse forward to collect [1,2,3]

example_3.py — Single node list

$ Input: node = ListNode(42) # Single node with no connections

› Output: [42]

💡 Note: Single node has no prev or next connections, so the result is simply [42]

Constraints

The number of nodes in the list is in the range [1, 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵
The given node is guaranteed to be part of a valid doubly linked list
All nodes in the list have proper prev and next connections

Visualization

Tap to expand

Understanding the Visualization

Assess Position

You start at an unknown position on the bridge (arbitrary node)

Find Beginning

Walk backward until you reach the start of the bridge (head node)

Map Bridge

Walk forward from start to end, recording each section (build result array)

Key Takeaway

🎯 Key Insight: In a doubly linked list, once you reach either endpoint (head or tail), you can traverse the entire structure efficiently in one direction, making this a linear time problem with optimal solution.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses a two-pass traversal: first navigate backward to find the head, then traverse forward to build the result array. This achieves O(n) time complexity with minimal constant factors, visiting each node at most twice. The key insight is that once we find either endpoint of the doubly linked list, we can traverse the entire structure in one direction efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Traversals)	O(n)	O(n)	Traverse the list multiple times to build the complete picture
Two-Pass Optimal Traversal	O(n)	O(n)	Find head first, then traverse once to build the result array

Brute Force (Multiple Traversals) — Algorithm Steps

Start from the given node and traverse forward to find the tail
From the tail, traverse backward to find the head while counting nodes
From the head, traverse forward again to build the result array
Each traversal visits all nodes, leading to multiple complete passes

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Tail

Traverse forward from given node to find the tail

Find Head

Traverse backward from tail to find the head

Build Array

Traverse forward again from head to build result

Code -

solution.c — C

// Definition for a Node.
struct ListNode {
    int val;
    struct ListNode *next;
    struct ListNode *prev;
};

int* solution(struct ListNode* node, int* returnSize) {
    if (!node) {
        *returnSize = 0;
        return NULL;
    }
    
    // First pass: find the tail
    struct ListNode* current = node;
    while (current->next) {
        current = current->next;
    }
    struct ListNode* tail = current;
    
    // Second pass: find the head and count
    current = tail;
    int count = 0;
    while (current) {
        count++;
        if (!current->prev) break;
        current = current->prev;
    }
    struct ListNode* head = current;
    
    // Third pass: build result array
    int* result = (int*)malloc(count * sizeof(int));
    current = head;
    int i = 0;
    while (current) {
        result[i++] = current->val;
        current = current->next;
    }
    
    *returnSize = count;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Although we make multiple passes, each pass is O(n), so total is still O(n) but with a high constant factor

✓ Linear Growth

Space Complexity

O(n)

Space for the result array containing n elements

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 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

Brute Force (Multiple Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler