如何在C#中使用Random类正确实现数组洗牌（解决元素重复问题）

Hey there! Let’s break down why your current code is spitting out duplicate elements and fix up your shuffle properly.

What’s Off with Your Current Code? #

Your approach right now doesn’t actually shuffle the array—it just randomly picks elements from a shrinking range (based on arr[i]) and prints them. That’s why duplicates happen: there’s no rule ensuring each element gets picked exactly once. Plus, using rand.Next(arr[i]) can lead to weird behavior—like when arr[i] is 1, you’ll only ever get index 0, so you’ll keep printing the first element over and over.

The Standard Solution: Fisher-Yates (Knuth) Shuffle #

The go-to, efficient way to shuffle an array is the Fisher-Yates Shuffle algorithm. It works by iterating from the end of the array backward, swapping each element with a randomly selected element from the unshuffled portion of the array. This guarantees every permutation is equally likely, and you’ll never get duplicates.

Fixed Code Example #

using System;

public class Program {
    public static void Main() {
        int[] arr = {1,2,3,4,5};
        Random rand = new Random();
        
        // Fisher-Yates Shuffle implementation
        for (int i = arr.Length - 1; i > 0; i--) {
            // Generate a random index from 0 to i (inclusive)
            int randomIndex = rand.Next(i + 1);
            
            // Swap the current element with the randomly selected one
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }
        
        // Print the fully shuffled array
        foreach (int num in arr) {
            Console.WriteLine(num);
        }
    }
}

How This Works #

• We start at the last element and move backward to the second element. Once an element is swapped to the end of the array, it’s locked in place and won’t be moved again.
• For each element at index i, we generate a random index between 0 and i (using rand.Next(i + 1) because Next() excludes the upper bound).
• Swapping the elements ensures every element has an equal chance of ending up in any position—no duplicates, no missed elements.

Bonus: Make It Reusable #

If you want to shuffle arrays of different types later, turn this into a generic method:

public static void Shuffle<T>(T[] array) {
    Random rand = new Random();
    for (int i = array.Length - 1; i > 0; i--) {
        int randomIndex = rand.Next(i + 1);
        T temp = array[i];
        array[i] = array[randomIndex];
        array[randomIndex] = temp;
    }
}

Then use it in your Main method like this:

Shuffle(arr);
foreach (int num in arr) {
    Console.WriteLine(num);
}

That should solve your shuffle problem perfectly! 😊

内容的提问来源于stack exchange，提问作者Glen