快捷導航

C#洗牌算法的具體實現(xiàn)

更新時間：2025年07月27日 09:50:50 作者：張謹?shù)W

洗牌算法是一種將序列元素隨機打亂的經(jīng)典算法,讓每個元素在打亂后出現(xiàn)在任意位置的概率均等,下面就來具體介紹一下洗牌算法的實現(xiàn),感興趣的可以了解一下

洗牌算法是一種將序列（如數(shù)組、列表）元素隨機打亂的經(jīng)典算法，核心目標是讓每個元素在打亂后出現(xiàn)在任意位置的概率均等。在 C# 中，常用的洗牌算法有Fisher-Yates 洗牌算法（也稱 Knuth 洗牌算法），它高效且公平，時間復雜度為 O (n)，空間復雜度為 O (1)。

一、Fisher-Yates 洗牌算法原理

核心思想：從序列的最后一個元素開始，依次與前面的隨機位置元素交換，直到處理完第一個元素。
公平性保證：每個元素被放置在任意位置的概率均為 1/n（n 為序列長度），避免了 “部分隨機” 導致的分布不均問題。

二、C# 實現(xiàn)示例

以下是使用 Fisher-Yates 算法對整數(shù)數(shù)組、字符串列表進行洗牌的實現(xiàn)：

代碼分塊分析

這段代碼是一個簡化的斗地主游戲?qū)崿F(xiàn)，主要包含撲克牌的生成、洗牌、發(fā)牌和排序功能。下面我將對代碼進行分塊分析。

1. 主程序結(jié)構(gòu)與初始化

static void Main(string[] args)
{
    int[] ints1 = new int[54];
    ints1 = RandomUNorepeatArray(ints1);
    
    // 后續(xù)代碼...
}

這部分代碼首先創(chuàng)建了一個包含 54 個元素的整數(shù)數(shù)組ints1，并調(diào)用RandomUNorepeatArray方法生成 0-53 的隨機不重復數(shù)組，用于作為撲克牌的隨機索引。

2. 撲克牌對象模型

class Puke
{
    public string number;
    public char color;
    
    public override string ToString()
    {
        return $"[{number},{color}]";
    }
}

Puke類表示一張撲克牌，包含兩個屬性：

number：牌面數(shù)字（字符串類型，"1"-"13" 或 "joker"）
color：花色（字符類型，' 黑 '、' 紅 '、' 梅 '、' 方 '）
重寫的ToString方法用于格式化輸出牌的信息

3. 撲克牌生成與初始化

Puke[] puke = new Puke[54];
int num = 1;
char[] str = new char[4] {'黑', '紅', '梅', '方' };
int num2 = 3;
for (int i = 0; i < 52; i++)
{
    puke[i] = new Puke();
    if (num > 13)
    {
        num = 1;
        num2--;
    }
    puke[i].number = num.ToString();
    num++;
    puke[i].color = str[num2];
}
puke[52] = new Puke { number = "joker", color = '黑' };
puke[53] = new Puke { number = "joker", color = '紅' };

這段代碼生成了 54 張撲克牌：

前 52 張是四種花色的 A-K（用數(shù)字 1-13 表示）
最后兩張是大小王（"joker"）

4. 洗牌與發(fā)牌

Puke[] puke2 = new Puke[54];
for (int i = 0; i < 54; i++)
{
    puke2[i] = puke[ints1[i]];
}
?
// 發(fā)牌給三個玩家和底牌
Puke[] puke3 = new Puke[17];
Puke[] puke4 = new Puke[17];
Puke[] puke5 = new Puke[17];
Puke[] puke6 = new Puke[3];
for (int i = 0; i < 17; i++)
{
    puke3[i] = puke2[ints1[i]];
    puke4[i] = puke2[ints1[i + 17]];
    puke5[i] = puke2[ints1[i + 24]]; // 這里索引計算有問題！
}
for(int i = 0; i < 3; i++)
{
    puke6[i] = puke2[ints1[i+51]];
}

這部分代碼實現(xiàn)了洗牌和發(fā)牌：

使用隨機索引數(shù)組ints1重新排列撲克牌數(shù)組
將牌分發(fā)給三個玩家（各 17 張）和底牌（3 張）

5. 排序算法

Array.Sort(puke3, (a, b) =>
{
    int numA = a.number == "joker" ? 100 : int.Parse(a.number);
    int numB = b.number == "joker" ? 100 : int.Parse(b.number);
    int result = numA.CompareTo(numB);
    if (result == 0)
        return a.color.CompareTo(b.color);
    return result;
});
?
// 對puke4和puke5有相同的排序代碼...

這部分代碼對每個玩家的手牌進行排序：

將牌面值轉(zhuǎn)換為整數(shù)進行比較（Joker 設(shè)為 100）
牌面值相同則比較花色

6. 輔助方法：生成隨機不重復數(shù)組

static int[] RandomUNorepeatArray(int[] ints )
{
    int min = 0;
    int max = 53;
    int count = 54;
?
    List<int> pool = new List<int>();
    for (int i = min; i <= max; i++)
        pool.Add(i);
?
    Random rand = new Random();
    // 洗牌算法
    for (int i = pool.Count - 1; i > 0; i--)
    {
        int j = rand.Next(0, i + 1);
        int temp = pool[i];
        pool[i] = pool[j];
        pool[j] = temp;
    }
?
    return pool.ToArray();
}

這個方法使用 Fisher-Yates 洗牌算法生成 0-53 的隨機排列數(shù)組。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
?
namespace 斗地主
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int[] ints1 = new int[54];
            ints1 = RandomUNorepeatArray(ints1);
?
            // //Console.WriteLine(string.Join(" ", ints1));
?
            // string[] strings = new string[]
            //{
            //     "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K",
            //     "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K",
            //     "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K",
            //     "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K",
            //     "j1", "j2"
            //};
?
            // string[] strings2 = new string[60];
?
            // Random random = new Random();
?
            // for (int i = 0; i < ints1.Length; i++)
            // {
            //    // int ints3 = random.Next(ints1.Length);
            //     strings2[i] = strings[ints1[i]];
            // }
            // int num = 0;
?
            // foreach (string s in strings2)
            // {
            //     Console.Write($"{s,-4}");
            //     num++;
            //     if (num % 17 == 0) Console.WriteLine();
            // }
?
            Puke[] puke = new Puke[54];
            int num = 1;
            char[] str = new char[4] {'黑', '紅', '梅', '方' };
            int num2 = 3;
            for (int i = 0; i < 52; i++)
            {
                puke[i] = new Puke();
                if (num > 13)
                {
                    num = 1;
                    num2--;
                }
                puke[i].number = num.ToString();
                num++;
                puke[i].color = str[num2];
            }
            puke[52] = new Puke { number = "joker", color = '黑' };
            puke[53] = new Puke { number = "joker", color = '紅' };
?
            Puke[] puke2 = new Puke[54];
            for (int i = 0; i < 54; i++)
            {
               puke2[i] = puke[ints1[i]];
            }
?
            int count = 0;
            foreach (var item in puke2)
            {
                Console.Write($"{item,-4}");
                count++;
                if (count % 17 == 0) Console.WriteLine();
?
                //count++;
                //if (count%13 == 0) Console.WriteLine();
            }
?
            Puke[] puke3 = new Puke[17];
            Puke[] puke4 = new Puke[17];
            Puke[] puke5 = new Puke[17];
            Puke[] puke6 = new Puke[3];
            for (int i = 0; i < 17; i++)
            {
                puke3[i] = puke2[ints1[i]];
                puke4[i] = puke2[ints1[i + 17]];
                puke5[i] = puke2[ints1[i + 24]];
            }
            for(int i = 0; i < 3; i++)
            {
                puke6[i] = puke2[ints1[i+51]];
            }
?
            Array.Sort(puke3, (a, b) =>
            {
                int numA = a.number == "joker" ? 100 : int.Parse(a.number);
                int numB = b.number == "joker" ? 100 : int.Parse(b.number);
                int result = numA.CompareTo(numB);
                if (result == 0)
                    return a.color.CompareTo(b.color);
                return result;
            });
?
            Array.Sort(puke4, (a, b) =>
            {
                int numA = a.number == "joker" ? 100 : int.Parse(a.number);
                int numB = b.number == "joker" ? 100 : int.Parse(b.number);
                int result = numA.CompareTo(numB);
                if (result == 0)
                    return a.color.CompareTo(b.color);
                return result;
            });
?
            Array.Sort(puke5, (a, b) =>
            {
                int numA = a.number == "joker" ? 100 : int.Parse(a.number);
                int numB = b.number == "joker" ? 100 : int.Parse(b.number);
                int result = numA.CompareTo(numB);
                if (result == 0)
                    return a.color.CompareTo(b.color);
                return result;
            });
?
            Console.WriteLine();
            Console.Write("=============================");
            Console.WriteLine();
?
            int c = 0;
            foreach (var item in puke3)
            {
                Console.Write($"{item,-6}");
                
                //count++;
                //if (count%13 == 0) Console.WriteLine();
            }
            Console.WriteLine();
            foreach (var item in puke4)
            {
                Console.Write($"{item,-6}");
            
                //count++;
                //if (count%13 == 0) Console.WriteLine();
            }
            Console.WriteLine();
            foreach (var item in puke5)
            {
                Console.Write($"{item,-6}");
                //count++;
                //if (count%13 == 0) Console.WriteLine();
            }
            Console.WriteLine();
            foreach (var item in puke6)
            {
                Console.Write($"{item,-6}");
                //count++;
                //if (count%13 == 0) Console.WriteLine();
            }
?
            //Array.Sort(puke2, (a, b) =>
            //{
            //    int result = a.number.CompareTo(b.number);
            //    if (result == 0)
            //    {
            //        return b.color.CompareTo(a.color);
            //    }
            //    return result;
            //});
?
        }
?
        
        //生成一定范圍內(nèi)隨機不成重復數(shù)字的數(shù)組
        static int[] RandomUNorepeatArray(int[] ints )
        {
            int min = 0;
            int max = 53; // 生成1~20之間的不重復數(shù)字
            int count = 54; // 需要的數(shù)量
?
            List<int> pool = new List<int>();
            for (int i = min; i <= max; i++)
                pool.Add(i);
?
            //Fisher-Yates 洗牌算法
            Random rand = new Random();
            // 洗牌
            for (int i = pool.Count - 1; i > 0; i--)
            {
                int j = rand.Next(0, i + 1);
                int temp = pool[i];
                pool[i] = pool[j];
                pool[j] = temp;
            }
?
            // 取前count個
            //for (int i = 0; i < count; i++)
            //{
            //    Console.Write(pool[i] + " ");
            //}
            //Console.WriteLine();
?
?
            return pool.ToArray();
        }
    }
?
?
    class Puke
    {
        // 牌的數(shù)字  A-K    用1-13表示
        public string number;
        // 牌的花色  黑紅梅方   4321
        public char color;
        public override string ToString()
        {
            return $"[{number},{color}]";
        }
?
    }
?
}
?

三、代碼說明

泛型方法：Shuffle<T> 支持任意類型的數(shù)組和列表，通用性強。
隨機索引生成：random.Next(i + 1) 確保生成的索引 j 在 [0, i] 范圍內(nèi)，避免越界。
元素交換：使用 C# 7.0 引入的元組交換語法 (a, b) = (b, a)，簡潔高效（也可使用臨時變量交換）。
Random 實例：在方法內(nèi)創(chuàng)建單個 Random 實例，避免短時間內(nèi)多次創(chuàng)建導致的隨機序列重復問題。

四、算法優(yōu)勢

公平性：每個元素在每個位置的概率嚴格相等，無偏差。
高效性：僅需一次遍歷和 n-1 次交換，時間復雜度 O (n)，空間復雜度 O (1)（原地洗牌，無需額外空間）。
適用性：適用于任何可索引的序列（數(shù)組、列表等），廣泛應(yīng)用于卡牌游戲、隨機排序、數(shù)據(jù)打亂等場景。

五、注意事項

Random 的線程安全：若在多線程環(huán)境中使用，需確保 Random 實例的線程安全（可使用 Random.Shared 或加鎖）。
重復執(zhí)行的隨機性：若需每次運行生成不同的打亂結(jié)果，不要手動指定 Random 的種子（默認使用系統(tǒng)時間作為種子）。

示例輸出

[8,梅][4,方][1,梅][3,梅][12,方][4,紅][9,黑][2,方][13,梅][9,方][7,黑][joker,紅][11,方][joker，黑][13,黑][9,紅][6,紅]
[10,紅][12,黑][9,梅][11,黑][3,紅][10,方][11,梅][12,梅][10,黑][6,梅][7,梅][2,紅][5,梅][12,紅][4,黑][3,黑][1,紅]
[10,梅][8,紅][6,方][5,紅][11,紅][1,黑][3,方][6,黑][5,黑][1,方][2,梅][13,紅][8,方][4,梅][8,黑][5,方][2,黑]
[7,方][7,紅][13,方]
=============================
[3,梅] [4,方] [4,梅] [4,黑] [5,梅] [7,方] [7,紅] [7,黑] [9,紅] [10,梅][10,黑][11,黑][13,方][13,梅][13,紅][joker,紅][joker,黑]
[2,紅] [2,黑] [3,紅] [5,方] [5,紅] [5,黑] [6,梅] [6,黑] [7,梅] [8,紅] [8,黑] [9,方] [9,梅] [10,紅][11,梅][12,梅][12,黑]
[1,梅] [1,紅] [1,黑] [4,紅] [5,紅] [5,黑] [6,方] [6,梅] [6,黑] [7,梅] [8,黑] [9,梅] [10,方][10,紅][12,梅][12,紅][12,黑]
[9,黑] [3,黑] [11,方]