Print Immutable Linked List in Reverse

Print Immutable Linked List in Reverse - Problem

You are given an immutable linked list, print out all values of each node in reverse with the help of the following interface:

ImmutableListNode: An interface of immutable linked list, you are given the head of the list.

You need to use the following functions to access the linked list (you can't access the ImmutableListNode directly):

ImmutableListNode.printValue(): Print value of the current node.
ImmutableListNode.getNext(): Return the next node.

The input is only given to initialize the linked list internally. You must solve this problem without modifying the linked list. In other words, you must operate the linked list using only the mentioned APIs.

Input & Output

Example 1 — Basic List

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

› Output: 4 3 2 1

💡 Note: Print each value in reverse order: start with 4 (last node), then 3, 2, and finally 1 (first node)

Example 2 — Single Node

$ Input: head = [1]

› Output: 1

💡 Note: Only one node, so print its value: 1

Example 3 — Two Nodes

$ Input: head = [1,2]

› Output: 2 1

💡 Note: Print in reverse: 2 (second node) then 1 (first node)

Constraints

1 ≤ Number of nodes ≤ 1000
0 ≤ Node.val ≤ 1000

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is to use recursion's natural property of unwinding in reverse order. The optimal recursive approach makes calls forward to the end, then prints values as the call stack unwinds. Time: O(n), Space: O(n)

Common Approaches

✓ Multiple Pass Solution

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

First pass counts total nodes, then for each position from end, traverse the list again to reach that specific node and print it.

Recursive Solution

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

Leverage recursion's call stack to achieve reverse printing. Make recursive calls first to reach the end, then print values as the recursion unwinds.

Stack-Based Solution

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

Use a stack data structure to collect all node values during a single forward traversal, then pop values from the stack to print them in reverse order.

Multiple Pass Solution — Algorithm Steps

Step 1: Traverse list once to count total nodes
Step 2: For each position from last to first, traverse list to reach that position and print

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Phase

Traverse once to count total nodes (n=4)

Print Phase

For each position from end, traverse again to reach that node

Result

Values printed in reverse order: 4, 3, 2, 1

Code -

solution.c — C

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

typedef struct ImmutableListNode {
    int val;
    struct ImmutableListNode* next;
} ImmutableListNode;

void printValue(ImmutableListNode* node) {
    printf("%d\n", node->val);
}

ImmutableListNode* getNext(ImmutableListNode* node) {
    return node->next;
}

void solution(ImmutableListNode* head) {
    if (!head) return;
    
    // Store node references
    ImmutableListNode* nodes[1000];
    int count = 0;
    
    ImmutableListNode* current = head;
    while (current) {
        nodes[count++] = current;
        current = getNext(current);
    }
    
    // Print nodes in reverse order
    for (int i = count - 1; i >= 0; i--) {
        printValue(nodes[i]);
    }
}

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

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int values[1000];
    int count = 0;
    
    // Parse JSON array format [1,2,3,4]
    char* start = strchr(line, '[');
    if (start) {
        start++; // Skip '['
        char* end = strchr(start, ']');
        if (end) {
            *end = '\0'; // Null terminate
            
            char* token = strtok(start, ",");
            while (token != NULL && count < 1000) {
                // Skip whitespace
                while (*token == ' ') token++;
                values[count++] = atoi(token);
                token = strtok(NULL, ",");
            }
        }
    }
    
    ImmutableListNode* head = buildList(values, count);
    solution(head);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Count nodes takes O(n), then for each of n nodes, traverse O(n) again

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for counting and indexing

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

843 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

Multiple Pass Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler