Linked List Random Node

最新推荐文章于 2024-09-06 04:39:09 发布

flyatcmu

最新推荐文章于 2024-09-06 04:39:09 发布

阅读量361

点赞数

CC 4.0 BY-SA版权

分类专栏： Math

本文链接：https://blog.youkuaiyun.com/u013325815/article/details/52261120

Math 专栏收录该内容

103 篇文章

订阅专栏

本文介绍了一种从链表中高效获取随机节点值的方法，并提供了两种实现思路：使用哈希表存储节点及其索引，以及采用水塘抽样算法。后者尤其适用于处理未知长度的大规模链表。

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

Given a singly linked list, return a random node's value from the linked list. Each node must have thesame 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();

思路：用hashmap来存node，和index，然后用随机函数来取。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {

    /** @param head The linked list's head.
        Note that the head is guaranteed to be not null, so it contains at least one node. */
    HashMap<Integer, ListNode> hashmap = new HashMap<Integer, ListNode>();
    private int length = 0;
    public Solution(ListNode head) {
        ListNode node = head;
        int index = 1;
        while(node!=null){
            length++;
            hashmap.put(index, node);
            node = node.next;
            index++;
        }
    }
    
    /** Returns a random node's value. */
    public int getRandom() {
        int value = (int)(Math.random()*length)+1;
        return hashmap.get(value).val;
    }
}

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

Follow up question: 实际上就是水塘采样。算法就是随时get当前的长度，取random [0,n)，如果取到0就取当前刚进来的node，如果不是，那就取之前那个random的值，这样能保证每个点都是随机的。证明过程，有个状态图。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {

    /** @param head The linked list's head.
        Note that the head is guaranteed to be not null, so it contains at least one node. */
    private ListNode curNode = null;
    private ListNode preNode = null;
    private ListNode beginNode = null;
    public Solution(ListNode head) {
       beginNode = head;
    }
    
    /** Returns a random node's value. */
    public int getRandom() {
        preNode = beginNode;
        curNode = beginNode;
        int count = 1;
        while(curNode != null) {
            int randValue = (int)(Math.random()*count); 
            if(randValue == 0){
                preNode = curNode;
            }
            curNode = curNode.next;
            count++;
        }
       
        return preNode.val;
    }
}

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