Print Immutable Linked List in Reverse - Practice Coding Problems

Print Immutable Linked List in Reverse - Problem

Imagine you have a special linked list that you can only read but never modify. Your challenge is to print all the values in reverse order without breaking any rules!

You're given an ImmutableListNode representing the head of this immutable linked list. You have access to only two methods:

ImmutableListNode.printValue(): Print the current node's value
ImmutableListNode.getNext(): Get the next node (or null if end)

The Challenge: Print all values in reverse order using only these two methods. You cannot modify the list, store the values directly, or access nodes through any other means.

For example, if the linked list contains [1, 2, 4, 3], you should print: 3, 4, 2, 1

Input & Output

example_1.py — Basic Case

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

› Output: 3 4 2 1

💡 Note: We traverse to the end recursively, then print values as we return: 3 (last) → 4 → 2 → 1 (first)

example_2.py — Single Node

$ Input: head = [5]

› Output: 5

💡 Note: Single node list - recursion reaches base case immediately, then prints the only value

example_3.py — Two Nodes

$ Input: head = [10,20]

› Output: 20 10

💡 Note: Two recursive calls: first reaches 20, hits null, returns and prints 20, then prints 10

Constraints

The length of the linked list is in the range [1, 1000]
The value of each node in the linked list is in the range [-1000, 1000]
Follow up: Could you solve it both recursively and iteratively?
You can only use the provided ImmutableListNode interface methods

Visualization

Tap to expand

Understanding the Visualization

The Problem

You have an audio guide that only plays forward, but you want to hear exhibits in reverse order

Brute Force

Count all exhibits, then for each position from end to start, walk through the entire guide to reach that exhibit

Stack Method

Walk through once taking notes on all exhibits, then read your notes backwards

Recursion Magic

Send friends ahead - each friend goes to the next exhibit, and they tell you about exhibits in reverse as they return

Key Takeaway

🎯 Key Insight: Recursion's natural LIFO behavior through the call stack automatically reverses the order - the last recursive call returns first, creating perfect reverse order output!

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses recursion to naturally reverse the printing order. By making recursive calls first and printing during the return phase, we leverage the call stack's LIFO behavior to achieve O(n) time and O(n) space complexity. Alternative approaches include using an explicit stack for the same complexity or a brute force nested loop approach with O(n²) time.

Common Approaches

Approach	Time	Space	Notes
✓ Stack Approach	O(n)	O(n)	Store all node references in a stack, then pop and print
Recursion Approach (Optimal)	O(n)	O(n)	Use recursion's natural LIFO behavior to print in reverse order

Stack Approach — Algorithm Steps

Create an empty stack
Traverse the list from head to end
Push each node reference onto the stack
Pop nodes from stack and print their values

Visualization

Tap to expand

Step-by-Step Walkthrough

Push Phase

Traverse list and push all nodes to stack

Pop Phase

Pop nodes and print values in reverse order

Code -

solution.c — C

#include <stdlib.h>
void printLinkedListInReverse(ImmutableListNode* head) {
    ImmutableListNode** stack = malloc(1000 * sizeof(ImmutableListNode*));
    int top = -1;
    ImmutableListNode* current = head;
    
    // Push all nodes onto stack
    while (current) {
        stack[++top] = current;
        current = getNext(current);
    }
    
    // Pop from stack and print (reverse order)
    while (top >= 0) {
        ImmutableListNode* node = stack[top--];
        printValue(node);
    }
    
    free(stack);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal to fill stack + single pass to empty stack

✓ Linear Growth

Space Complexity

O(n)

Stack stores reference to each node in the list

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~12 min Avg. Time

845 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

Stack Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler