Convert Doubly Linked List to Array II

Convert Doubly Linked List to Array II - Problem

You are given an arbitrary node from a doubly linked list, which contains nodes that have a next pointer and a previous pointer. Return an integer array which contains the elements of the linked list in order.

Since you start from an arbitrary node (not necessarily the head), you need to first find the beginning of the list, then traverse from head to tail to collect all values.

Input & Output

Example 1 — Starting from Middle

$ Input: node pointing to value 3 in list [1,2,3,4,5]

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

💡 Note: Starting from node with value 3, we move backward to find head (value 1), then traverse forward collecting all values: 1→2→3→4→5

Example 2 — Starting from Head

$ Input: node pointing to value 10 in list [10,20,30]

› Output: [10,20,30]

💡 Note: Starting from head node (value 10), no backward movement needed, just traverse forward: 10→20→30

Example 3 — Single Node

$ Input: node pointing to value 42 in list [42]

› Output: [42]

💡 Note: List has only one node, so it's both head and tail. 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 doubly linked list

Visualization

Tap to expand

Asked in

M Microsoft 25 a Amazon 20 G Google 15

The key insight is to first find the head of the doubly linked list by moving backward, then traverse forward to collect all values. The optimal approach uses O(n) time with two passes: one to find the head and one to collect values. Space complexity is O(n) for the result array.

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Find Head Then Traverse

⏱️ Time: O(n) Space: O(n)

First traverse backward using previous pointers until we reach the head (node with no previous). Then traverse forward using next pointers, collecting all values into an array.

Single Pass with Size Calculation

⏱️ Time: O(n) Space: O(n)

First find the head by going backward. Then make one forward pass to count total nodes and allocate the exact array size. Finally, traverse forward again to collect all values efficiently.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct ListNode {
    int val;
    struct ListNode* next;
    struct ListNode* prev;
} ListNode;

static int result[10000];
static ListNode* visited[10000];

int* solution(ListNode* node, int* returnSize) {
    *returnSize = 0;
    if (!node) {
        return result;
    }
    
    // Memoization to avoid revisiting nodes when finding head
    int visitedCount = 0;
    
    // Find head using memoization to track visited nodes
    ListNode* current = node;
    while (current->prev) {
        // Check if already visited
        int found = 0;
        for (int i = 0; i < visitedCount; i++) {
            if (visited[i] == current) {
                found = 1;
                break;
            }
        }
        if (found) break;
        
        visited[visitedCount++] = current;
        current = current->prev;
    }
    
    ListNode* head = current;
    
    // Traverse from head to collect all values
    current = head;
    while (current) {
        result[(*returnSize)++] = current->val;
        current = current->next;
    }
    
    return result;
}

int* parseArray(const char* s, int* size) {
    static int values[10000];
    *size = 0;
    
    if (strlen(s) <= 2) return values; // "[]" case
    
    char* str = malloc(strlen(s) + 1);
    strcpy(str, s);
    
    // Remove brackets
    char* content = str + 1;
    content[strlen(content) - 1] = '\0';
    
    if (strlen(content) == 0) {
        free(str);
        return values;
    }
    
    char* token = strtok(content, ",");
    while (token != NULL) {
        values[(*size)++] = (int)strtol(token, NULL, 10);
        token = strtok(NULL, ",");
    }
    
    free(str);
    return values;
}

int main() {
    char valuesLine[1000];
    int startIndex;
    
    fgets(valuesLine, sizeof(valuesLine), stdin);
    // Remove newline
    valuesLine[strcspn(valuesLine, "\n")] = 0;
    
    scanf("%d", &startIndex);
    
    int valueCount;
    int* values = parseArray(valuesLine, &valueCount);
    
    if (valueCount == 0) {
        printf("[]\n");
        return 0;
    }
    
    // Create nodes
    ListNode* nodes[10000];
    for (int i = 0; i < valueCount; i++) {
        nodes[i] = malloc(sizeof(ListNode));
        nodes[i]->val = values[i];
        nodes[i]->next = NULL;
        nodes[i]->prev = NULL;
    }
    
    // Link nodes
    for (int i = 0; i < valueCount; i++) {
        if (i > 0) {
            nodes[i]->prev = nodes[i-1];
        }
        if (i < valueCount - 1) {
            nodes[i]->next = nodes[i+1];
        }
    }
    
    // Get starting node
    ListNode* startNode = nodes[startIndex];
    
    // Call solution and print result
    int returnSize;
    int* result = solution(startNode, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    // Clean up memory
    for (int i = 0; i < valueCount; i++) {
        free(nodes[i]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

850 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