用于从单链表中选择随机节点的Python程序

给定一个单链表，从链表中随机选择一个节点（如果列表中有 N 个节点，选择一个节点的概率应该是 1/N）。您将获得一个随机数生成器。
下面是一个简单的解决方案：

通过遍历列表来计算节点数。
再次遍历列表并选择概率为 1/N 的每个节点。可以通过为第 i 个节点生成一个从 0 到 Ni 的随机数来完成选择，并且仅当生成的数字等于 0（或从 0 到 Ni 的任何其他固定数字）时才选择第 i 个节点。

通过上述方案，我们得到了统一的概率。

i = 1, probability of selecting first node = 1/N
i = 2, probability of selecting second node =
                   [probability that first node is not selected] * 
                   [probability that second node is selected]
                  = ((N-1)/N)* 1/(N-1)
                  = 1/N

类似地，其他选择其他节点的概率为 1/N
上述方案需要对链表进行两次遍历。

如何选择一个只允许遍历一次的随机节点？
这个想法是使用 Reservoir Sampling。以下是步骤。这是 Reservoir Sampling 的一个更简单的版本，因为我们只需要选择一个键而不是 k 个键。

(1) Initialize result as first node
    result = head->key 
(2) Initialize n = 2
(3) Now one by one consider all nodes from 2nd node onward.
    (a) Generate a random number from 0 to n-1. 
        Let the generated random number is j.
    (b) If j is equal to 0 (we could choose other fixed numbers 
        between 0 to n-1), then replace result with the current node.
    (c) n = n+1
    (d) current = current->next

下面是上述算法的实现。

Python

# Python program to randomly select a 
# node from singly linked list 
import random
  
# Node class 
class Node:
  
    # Constructor to initialize the 
    # node object
    def __init__(self, data):
        self.data= data
        self.next = None
  
class LinkedList:
  
    # Function to initialize head
    def __init__(self):
        self.head = None
  
    # A reservoir sampling-based function 
    # to print a random node from a 
    # linked list
    def printRandom(self):
  
        # If list is empty 
        if self.head is None:
            return
  
        if self.head and not self.head.next:
           print "Randomly selected key is %d" %(self.head.data)
  
        # Use a different seed value so that we don't get 
        # same result each time we run this program
        random.seed()
  
        # Initialize result as first node
        result = self.head.data
  
        # Iterate from the (k+1)th element nth element
        # because we iterate from (k+1)th element, or 
        # the first node will be picked more easily 
        current = self.head.next 
        n = 2 
        while(current is not None):
              
            # Change result with probability 1/n
            if (random.randrange(n) == 0 ):
                result = current.data 
  
            # Move to next node
            current = current.next
            n += 1
  
        print "Randomly selected key is %d" %(result)
          
    # Function to insert a new node at 
    # the beginning
    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node
  
    # Utility function to print the linked 
    # LinkedList
    def printList(self):
        temp = self.head
        while(temp):
            print temp.data,
            temp = temp.next
  
# Driver code
llist = LinkedList()
llist.push(5)
llist.push(20)
llist.push(4)
llist.push(3)
llist.push(30)
llist.printRandom()
# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

请注意，上述程序是基于随机函数的结果，可能会产生不同的输出。

这是如何运作的？
让列表中总共有 N 个节点。从最后一个节点开始更容易理解。
最后一个节点是结果的概率只是 1/N [对于最后一个或第 N 个节点，我们生成一个介于 0 到 N-1 之间的随机数，如果生成的数字为 0（或任何其他固定值），则将最后一个节点作为结果数字]
倒数第二个节点是结果的概率也应该是 1/N。

The probability that the second last node is result 
          = [Probability that the second last node replaces result] X 
            [Probability that the last node doesn't replace the result] 
          = [1 / (N-1)] * [(N-1)/N]
          = 1/N

同样，我们可以显示^第三个最后一个节点和其他节点的概率。
有关详细信息，请参阅有关从单链表中选择随机节点的完整文章！