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?

這道題如果不考慮follow up會很簡單，遍歷一遍鏈表，把值存到一個List里，取的時候隨機出一個下標來取就好。

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 ArrayList<Integer> a=new ArrayList<Integer>(); 
    private int b = 0;
    public Solution(ListNode head) {
        while (head!=null) {
            a.add(head.val);
            head = head.next;
            b++;
        }
    }
    
    /** Returns a random node's value. */
    public int getRandom() {
        int index = (int)(Math.random()*(b));
        int res = a.get(index);
        return res;
    }
}

但是，如果在長度未知的情況下進行隨機，這個就不行了，比如鏈表是隨時變化的，就不能用這樣的方法。
這是著名的蓄水池問題，在未知長度的數(shù)據(jù)中隨機出k個數(shù)據(jù)。
比如，我們要從1，2，3中隨機選出一個。
假設我們的結(jié)果是res
我們從頭開始遍歷這個鏈表：
遍歷到第一個時，我們選1的概率是1，res=1
遍歷到第二個時，我們選2的概率應該是1/2，1的概率也應該是是1/2。我們以1/2的概率執(zhí)行res＝2
遍歷到第三個時，我們選每個數(shù)的概率是1/3，我們以1/3的概率執(zhí)行res＝3
此時，res＝1，2，3的概率分別是1/2(1-1/3),1/2(1-1/3),1/3。即1/3，1/3，1/3
所以：

public class Solution {
    ListNode head;
    Random random;
    public Solution(ListNode head) {
        this.head = head;
        random = new Random();
    }
    
    /** Returns a random node's value. */
    public int getRandom() {
        int count = 0;
        int result = -1;
        ListNode dummyhead = head;
        while(dummyhead != null) {
            if(random.nextInt(++count) == 0) {
                result = dummyhead.val;
            }
            dummyhead = dummyhead.next;
        }
        return result;
    }
}

Random Pick Index

Given an array of integers with possible duplicates, randomly output the index of a given target number. You can assume that the given target number must exist in the array.
Note:The array size can be very large. Solution that uses too much extra space will not pass the judge.
Example:

int[] nums = new int[] {1,2,3,3,3};
Solution solution = new Solution(nums);
// pick(3) should return either index 2, 3, or 4 randomly. Each index should have equal probability of returning.
solution.pick(3);
// pick(1) should return 0. Since in the array only nums[0] is equal to 1.
solution.pick(1);

這個和上面的問題幾乎一樣的，就是這次選的時候只在特定的值中選

public class Solution {
    int [] data;
    Random random;
    public Solution(int[] nums) {
        data = nums;
        random = new Random();
    }
    
    public int pick(int target) {
        int count = 0;
        int result = -1;
        for(int i = 0;i<data.length;i++) {
            if (data[i]==target) {
                 if(random.nextInt(++count) == 0) {
                    result = i;
                }
            }
        }
        return result;
    }
}