LeetCode - Linked List Random Node

最新推荐文章于 2024-09-13 17:37:10 发布

japinli

最新推荐文章于 2024-09-13 17:37:10 发布

阅读量358

点赞数

CC 4.0 BY-SA版权

分类专栏： c++ 文章标签： leetcode Reservoir

本文链接：https://blog.youkuaiyun.com/japinli/article/details/52230271

c++ 专栏收录该内容

8 篇文章

订阅专栏

本文介绍了一种在不预先知道链表长度的情况下从链表中随机选取节点的方法，并详细解释了Reservoir Sampling算法的工作原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

382. Linked List Random Node

题目

Given a singly linked list, return a random node’s value from the linked list. Each node must have the same probability of being chosen.

Follow up:
What if the linked list is extremely large and its length is unknown to you? Could you solve this efficiently without using extra space?

Example:

// Init a singly linked list [1,2,3].
ListNode head = new ListNode(1);
head.next = new ListNode(2);
head.next.next = new ListNode(3);
Solution solution = new Solution(head);

// getRandom() should return either 1, 2, or 3 randomly. Each element should have equal probability of returning.
solution.getRandom();

思路

若是链表长度已知（或通过先遍历链表获取链表长度）为 $n$ ，那么这题就可以通过随机生成一个在区间 $[0, n-1]$ 内的整数，然后遍历链表到相应节点即可。
可题目给出限制条件为链表足够大且长度未知，因此上述方法不能满足题目要求。Reservoir Sampling算法很好的解决了这个问题。该算法步骤如下：

使第一个元素为待返回元素；
当第 i 个元素到达时（i>1）：
- 若概率为 $1/i$ ，则使用该元素替换待返回元素；
- 反之概率为 $1-1/i$ ，则丢弃该元素。

例如

当仅有一个元素时，它的概率为 $1$ ，始终返回该元素对应的值。
当有两个元素时，每个元素的概率都为 $\frac{1}{2}$ 。
当有三个元素时，第三个元素的概率保持为 $\frac{1}{3}$ ，其他元素的概率则为 $\frac{1}{2}\times(1-\frac{1}{3})=\frac{1}{3}$ 。
当有 $n$ 个元素时，第 $n$ 个元素的概率保持为 $\frac{1}{n}$ ，其他元素的概率则为 $\frac{1}{n-1}\times(1-\frac{1}{n})=\frac{1}{n}$ 。因此，每个元素出现的概率均相等。

Wikipedia上原文如下：

Suppose we see a sequence of items, one at a time. We want to keep a single item in memory, and we want it to be selected at random from the sequence. If we know the total number of items (n), then the solution is easy: select an index i between 1 and n with equal probability, and keep the i-th element. The problem is that we do not always know n in advance. A possible solution is the following:

Keep the first item in memory.
When the $i$ -th item arrives (for $i>1$ ):

with probability $1/i$ , keep the new item instead of the current item; or equivalently
with probability $1-1/i$ , keep the current item and discard the new item.

So:

when there is only one item, it is kept with probability 1;
when there are 2 items, each of them is kept with probability 1/2;
when there are 3 items, the third item is kept with probability 1/3, and each of the previous 2 items is also kept with probability (1/2)(1-1/3) = (1/2)(2/3) = 1/3;
by induction, it is easy to prove that when there are n items, each item is kept with probability 1/n.

示例代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    /** @param head The linked list's head.
        Note that the head is guaranteed to be not null, so it contains at least one node. */
    Solution(ListNode *head) : head_(head) {
    }

    /** Returns a random node's value. */
    int getRandom() {
        int ret = head_->val;
        ListNode *node = head_;

        for (int i = 1; node; ++i, node = node->next) {
            if (rand() % i == 0) {  /* probabity = 1/i */
                ret = node->val;
            }
        }

        return ret;
    }

private:
    ListNode *head_;
};

/**
 * Your Solution object will be instantiated and called as such:
 * Solution obj = new Solution(head);
 * int param_1 = obj.getRandom();
 */