(Counting & Probability) Fisher-Yates Shuffling & Implementation in Java

Motivation

• We have $n\ge 1$ distinct objects i.e. an array of length $n$ with distinct objects, and we want to shuffle them using an algorithm such that every possible permutation out of a totally of $n!$ is equally likely.

The Algorithm

Description

• Suppose we are given a random number generator.
• Start from the last element of the array, generate a random integer between $0$ and $n-1$ (all inclusive), say $r_1$, and swap the $r_1$th and the $(n-1)$th elements.
• Then generate a random integer between $0$ and $n-2$, say $r_2$, then we swap the $r_2$th and the $n-2$th elements.
• Continue this process until we get to generate a random integer between $0$ and $1$, say $r_{n-1}$, then we swap $r_{n-1}$st and $1$th elements.
• No matter what we generated in the last step, the next step only allows us to generate $0=r_n$ as the only possible random integer, so we keep everything unchanged as we are swapping $0$th element and the $0$th element. Thus, this last step is never needed.
• One shuffling is completed.

Pseudo Code

• Assume arr is an array of length $n\ge 1$. Assuming the array index starts at $0$:

for i = n-1,....,1{ // the i = 0 step is not actually needed
	l = randInt 0 <= l <= i
	swap(arr[i], arr[l])
}

Proof

• Let the index start from $1$ from now on. We want to prove that for any permutation of the $n$ objects in the original array, the probability of obtaining it by the algorithm is always $\frac{1}{n!}$.
• Observe a fact from the algorithm:
  • After the first step, whichever object from the original array gets fixed to the last position stay fixed forever because after the first step, the second step will only exchange two terms among the previous $n-1$ terms.
  • Same for the second step: after the second step, whichever object gets fixed to the next-to-the-last position gets fixed forever and so on.
• Thus, a direct result of this observation is that once we choose some permutation of the objects of the original array, we can build this permutation by $n$ consecutive steps that needs to be done in such an order that the first step is to decide which term goes to the last position, the second step is to decide which goes to the next to last position and so on, which will, in turn, allows us to use the multiplication principle.
• Therefore, assume $a_1,...,a_n$ is an arbitrary permutation, with their original indices in the array being $x_1,....,x_n$. We examine all the steps needed to obtain this permutation:
• The first step generates a random integer between $1$ and $n$, so if the generator is indeed random, the probability of generating $x_n$ from { 1 , . . . , n } \{1,...,n\} {1,...,n} is $\frac{1}{n}$, therefore, the probability that $a_n$ gets fixed to the last position is $\frac{1}{n}$.
• The second step generates a random integer in S = { 1 , . . . , n } ∖ { x n } S=\{1,...,n\} \setminus \{x_n\} S={1,...,n}∖{xn​}, which are $n-1$ integers, so P ( { P(\{ P({generating $x_{n-1}\in S\})=\frac{1}{n-1}$, which is the probability that $a_{n-1}$ gets fixed to the $(n-1)$th position.
• Similarly, the probability that $a_{n-2}$ gets fixed to the $(n-2)$th position is thus $\frac{1}{n-2}$.
• This process continues until we have reached the $1$st position, where the only integer that can be generated is $1$, and we only have one index, $x_1$, left (as we have chosen $n-1$ integers already), so the probability that $a_1$ gets fixed to the first position is certainly $1$.
• By multiplication principle, since we achieved the permutation $a_1,...,a_n$ by these $n$ consecutive steps, the probability of getting this permutation is thus $\frac{1}{n}\cdot \frac{1}{n-1}...\cdot 1=\frac{1}{n!}$

Implementation in Java

	int n = 5;
	char[] CardValues = new char[] {'a','b','c','d','e'};
  	for(int i = n-1; i >= 0; i--){
  		int r = (int) ((i + 1) * Math.random()); // r in [0,i]
  		char temp = CardValues[i];
  		CardValues[i] = CardValues[r];
  		CardValues[r] = temp;
  	}