Shuffling Arrays with the Fisher-Yates Algorithm in Java

Introduction

In the realm of computer science, shuffling an array or list of elements is a common operation that can be useful in various applications, from randomizing game outcomes to distributing cards in a deck. One of the most effective algorithms for this purpose is the Fisher-Yates Shuffle, also known as the Knuth Shuffle. This algorithm ensures that each permutation of the array is equally likely, which makes it an ideal choice for creating unbiased random shuffles.

In this article, we'll explore a Java implementation of the Fisher-Yates Shuffle algorithm. The code provided efficiently shuffles an array of integers in place, demonstrating both the elegance and effectiveness of this algorithm.

The Fisher-Yates Shuffle Algorithm

The Fisher-Yates Shuffle algorithm operates by iterating over the array from the end to the beginning, swapping each element with a randomly chosen element that appears earlier in the array (including the current position). This process ensures that all permutations of the array are equally probable.

Java Code Implementation

Here is a Java implementation of the Fisher-Yates Shuffle algorithm:

import java.util.*;

class FYShuffleAlgorithm {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};

        shuffle(arr);
    }

    public static void shuffle(int[] arr) {
        Random rand = new Random();
        for (int i = arr.length - 1; i > 0; i--) {
            int randomIndex = rand.nextInt(i + 1);
            int tmp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = tmp;
        }
        System.out.println(Arrays.toString(arr));
    }
}

Explanation of the Code
Initialization:
The main method initializes an array of integers arr with the values {1, 2, 3, 4, 5, 6} and then calls the shuffle method to shuffle this array.