Codestin Search App

Linked List Random Node - Problem

Linked List Random Node is a fascinating problem that combines probability theory with data structures. You're given a singly linked list and need to implement a class that can return a random node's value from the list with equal probability for each node.

The challenge is that linked lists don't provide random access like arrays do - you can't just jump to index 3 or 7. You need to traverse from the head each time. Your task is to implement:

Solution(ListNode head) - Initialize with the linked list head
int getRandom() - Return a random node's value where each node has equal probability of being chosen

This problem tests your understanding of reservoir sampling, a clever technique for selecting random samples from a stream of unknown length. It's particularly useful when you can't store all elements in memory or when the size is unknown.

Input & Output

example_1.py — Basic Usage

$ Input: list = [1, 2, 3] solution = Solution(list) solution.getRandom() # calls

› Output: Possible outputs: 1, 2, or 3 (each with equal probability)

💡 Note: With 3 nodes in the list, each node should be selected approximately 1/3 of the time over many calls. The exact return value is random but the distribution should be uniform.

example_2.py — Single Node

$ Input: list = [5] solution = Solution(list) solution.getRandom()

› Output: 5

💡 Note: When there's only one node, that node must always be selected, so the result is deterministic.

example_3.py — Multiple Calls

$ Input: list = [1, 2] solution = Solution(list) [solution.getRandom() for _ in range(6)]

› Output: Possible: [1, 2, 1, 1, 2, 2] or any other combination

💡 Note: Each call is independent. With 2 nodes, over many calls we expect roughly 50% to return 1 and 50% to return 2, but individual sequences can vary.

Constraints

The number of nodes in the linked list will be in the range [1, 10⁴]
-10⁴ <= Node.val <= 10⁴
At most 10⁴ calls will be made to getRandom
Follow up: What if the linked list is extremely large and its length is unknown to you?

Visualization

Tap to expand

Understanding the Visualization

Start the Journey

Begin with first node as your choice - it's 100% likely to be selected so far

Second Node Decision

Flip a fair coin (50% chance) - replace or keep? Now both nodes have equal 50% probability

Third Node Magic

Roll a 3-sided die - replace with 1/3 probability. All three nodes now have exactly 1/3 probability!

Pattern Continues

For nth node, replace with 1/n probability. Mathematics ensures perfect fairness!

Key Takeaway

🎯 Key Insight: Reservoir sampling proves that you don't need to know the total size to achieve perfect randomness. By using decreasing replacement probability (1/n for the nth element), each element maintains exactly 1/n final probability of selection!

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 24 Apple 18

The optimal solution uses Reservoir Sampling, a brilliant algorithm that selects random elements from streams of unknown length. Instead of counting nodes first, we maintain a running selection by replacing our current choice with probability 1/i for each node at position i. This mathematically guarantees equal probability for all nodes while requiring only O(1) space and a single pass. The algorithm works by starting with the first node and deciding whether to replace it with each subsequent node using decreasing probability.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Counting	O(n)	O(1)	Count nodes first, then traverse again to find the random index
Reservoir Sampling (Optimal)	O(n)	O(1)	Use reservoir sampling algorithm to select random node in single pass

Two-Pass Counting — Algorithm Steps

Count total nodes by traversing the entire linked list
Generate a random index between 0 and count-1
Traverse the list again to reach the randomly selected index
Return the value at that index

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Phase

Traverse the entire list to count total nodes

Random Generation

Generate random index between 0 and count-1

Selection Phase

Traverse again to reach the randomly selected index

Code -

solution.c — C

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

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

typedef struct {
    struct ListNode* head;
} Solution;

Solution* solutionCreate(struct ListNode* head) {
    Solution* obj = (Solution*)malloc(sizeof(Solution));
    obj->head = head;
    srand(time(NULL));
    return obj;
}

int solutionGetRandom(Solution* obj) {
    // First pass: count nodes
    int count = 0;
    struct ListNode* current = obj->head;
    while (current) {
        count++;
        current = current->next;
    }
    
    // Generate random index
    int randomIndex = rand() % count;
    
    // Second pass: find the node at randomIndex
    current = obj->head;
    for (int i = 0; i < randomIndex; i++) {
        current = current->next;
    }
    
    return current->val;
}

void solutionFree(Solution* obj) {
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each getRandom() call requires O(n) to count nodes + O(n) to reach random index = O(n)

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and pointers

✓ Linear Space

68.4K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

Two-Pass Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler