Convert Doubly Linked List to Array I

Convert Doubly Linked List to Array I - Problem

You are given the head of 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.

Note: A doubly linked list allows traversal in both forward and backward directions.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Traverse the doubly linked list from head: 1 → 2 → 3 → 4, collect each value into array

Example 2 — Single Node

$ Input: head = [5]

› Output: [5]

💡 Note: Only one node in the list, so the result array contains just that single value

Example 3 — Negative Values

$ Input: head = [-1,0,1]

› Output: [-1,0,1]

💡 Note: Doubly linked list with negative, zero, and positive values: -1 → 0 → 1

Constraints

The number of nodes in the linked list is in the range [1, 1000]
-1000 ≤ Node.val ≤ 1000

Visualization

Tap to expand

Asked in

A Amazon 25 M Microsoft 18

The key insight is to simply traverse the doubly linked list from head to tail, collecting each node's value into a result array. Since we need to visit every node exactly once, this approach is optimal with O(n) time and O(n) space complexity.

Common Approaches

✓ Linear Traversal

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

Start at the head node and follow the next pointers until reaching the end. For each node visited, add its value to the result array. Since we only need to visit each node once, this is actually the optimal approach.

Linear Traversal — Algorithm Steps

Step 1: Initialize empty result array
Step 2: Start from head node
Step 3: While current node exists, add value to array and move to next node
Step 4: Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Head

Begin traversal at the head node

Collect Values

Visit each node and add its value to result array

Result Array

Final array contains all node values in order

Code -

solution.c — C

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

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

int* solution(struct ListNode* head, int* returnSize) {
    *returnSize = 0;
    struct ListNode* temp = head;
    while (temp) {
        (*returnSize)++;
        temp = temp->next;
    }
    
    int* result = (int*)malloc(*returnSize * sizeof(int));
    struct ListNode* current = head;
    int index = 0;
    while (current) {
        result[index++] = current->val;
        current = current->next;
    }
    return result;
}

struct ListNode* buildDoublyLinkedList(int* values, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = values[0];
    head->next = NULL;
    head->prev = NULL;
    
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
        newNode->val = values[i];
        newNode->next = NULL;
        newNode->prev = current;
        current->next = newNode;
        current = newNode;
    }
    return head;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int values[1000];
    int count = 0;
    if (strlen(line) > 2) {
        char* token = strtok(line + 1, ",]");
        while (token) {
            values[count++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    struct ListNode* head = buildDoublyLinkedList(values, count);
    int returnSize;
    int* result = solution(head, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n nodes in the linked list

✓ Linear Growth

Space Complexity

O(n)

Result array stores n elements from the linked list

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~8 min Avg. Time

891 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

Linear Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler