leetcode 382 Linked List Random Node 链表随机节点

 

假设数据规模为n，采样为k,

蓄水池采样算法是针对大数据集或者数据规模不确定的算法：空间为k,时间为n,

• 先选取数据流中的前k个元素，保存在集合A中；
• 从第j（k + 1 <= j <= n）个元素开始，每次先以概率p = k/j选择是否让第j个元素留下。若j被选中，则从A中随机选择一个元素并用该元素j替换它；否则直接淘汰该元素；
• 重复步骤2直到结束，最后集合A中剩下的就是保证随机抽取的k个元素。

具体证明参见：蓄水池采样证明及java代码

以及：

 C++代码：知道总体长度产生（0~n-1）的随机数方法：

/**
 * 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) {
        len=0;
        ListNode* cur=head;
        this->head = head;
        while(cur){
            len++;
            cur=cur->next;
        }
    }
    
    /** Returns a random node's value. */
    int getRandom() {
        int t = rand() % len;//产生0~(len-1)之间的随机数
        ListNode* cur=head;
        while(t){
            t--;
            cur=cur->next;
        }
        return cur->val;
    }
private:
    int len;
    ListNode* head;
};

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

 C++解法二：蓄水池算法

/**
 * 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) {
        this->head = head;
    }
    
    /** Returns a random node's value. */
    int getRandom() {
        ListNode* cur=head->next;
        int res=head->val;
        int j=2;
        //维护一个长度为1的蓄水池，每次抽取概率1/j；
        while(cur){
            int t=rand()%j;
            if(t==0) res=cur->val;
            cur=cur->next;
            j++;
        }
        return res;
    }
private:
    ListNode* head;
};

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

执行92ms,看看执行28ms的

 leetcode答案执行效率28ms

/**
 * 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. */
    
    int length = 0;
    struct ListNode* h;
    
    Solution(ListNode* head) {
        h = head;
        struct ListNode* p = head;
        while(p)
        {
            length++;
            p = p->next;
        }
    }
    
    /** Returns a random node's value. */
    int getRandom() {
        int n = random()%length;
        int i;
        struct ListNode* p = h;
        for(i=0;i<n;i++)
            p = p->next;
        return p->val;
    }
};

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