LeetCode - Linked List Random Node

最新推荐文章于 2020-03-05 10:39:53 发布

japinli

最新推荐文章于 2020-03-05 10:39:53 发布

阅读量310

点赞数

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

本文链接：https://blog.csdn.net/japinli/article/details/52230271

版权

c++ 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

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();
 */