《Shuffle》算法，中文洗牌算法，数组的随机排列源代码

admin

算法特点：

原地操作：直接修改原数组，不产生额外内存开销

时间复杂度O(n)：只需单次遍历即可完成随机排列

均匀分布：保证每个排列出现的概率相等

泛型支持：适用于任何类型的数组（int、string、自定义类等）

注意事项：

需要确保已经 using UnityEngine; 命名空间

如果需要在非主线程使用，建议使用 System.Random 替代并传入随机种子

对于List集合，可以直接用相同算法原理实现


这个实现是游戏开发中常用的标准洗牌方法，适用于卡牌游戏、随机道具生成、NPC行为随机化等场景。

1. using UnityEngine;
   
2. 
   
3. public static class ArrayExtensions
   
4. {
   
5.     /// <summary>
   
6.     /// 使用Fisher-Yates算法随机打乱数组
   
7.     /// </summary>
   
8.     /// <param name="array">需要打乱的数组（会被直接修改）</param>
   
9.     public static void Shuffle<T>(this T[] array)
   
10.     {
    
11.         // 从最后向前遍历数组
    
12.         for (int i = array.Length - 1; i > 0; i--)
    
13.         {
    
14.             // 生成一个0到i（包含i）的随机索引
    
15.             int randomIndex = Random.Range(0, i + 1);
    
16.             
    
17.             // 交换当前元素和随机位置的元素
    
18.             T temp = array[i];
    
19.             array[i] = array[randomIndex];
    
20.             array[randomIndex] = temp;
    
21.         }
    
22.     }
    
23. }

复制代码

1. // 创建一个测试数组
   
2. int[] myArray = { 1, 2, 3, 4, 5 };
   
3. 
   
4. // 打乱数组
   
5. myArray.Shuffle();
   
6. 
   
7. // 输出结果
   
8. foreach (int num in myArray)
   
9. {
   
10.     Debug.Log(num);
    
11. }

复制代码

扩展用法：
如果需要保留原始数组并创建新的乱序副本，可以添加以下方法：

1. public static T[] ShuffledCopy<T>(this T[] array)
   
2. {
   
3.     T[] copy = (T[])array.Clone();
   
4.     copy.Shuffle();
   
5.     return copy;
   
6. }

复制代码

admin

1️⃣ 需求分析 若想实现类似 0-99 范围内 所有整数随机出现且不重复 的效果（类似抽奖号码的随机洗牌），可以按以下步骤实现：

1. using UnityEngine;
   
2. 
   
3. public class RangeShuffleExample : MonoBehaviour
   
4. {
   
5.     void Start()
   
6.     {
   
7.         // 生成 0-99 的数组并洗牌
   
8.         int[] randomNumbers = GenerateShuffledRange(0, 99);
   
9.         
   
10.         // 按洗牌后的顺序使用数值
    
11.         foreach(int num in randomNumbers)
    
12.         {
    
13.             Debug.Log(num); // 输出：随机排列的0-99
    
14.         }
    
15.     }
    
16. 
    
17.     /// <summary>
    
18.     /// 生成指定范围的随机乱序数组
    
19.     /// </summary>
    
20.     /// <param name="min">最小值（包含）</param>
    
21.     /// <param name="max">最大值（包含）</param>
    
22.     public static int[] GenerateShuffledRange(int min, int max)
    
23.     {
    
24.         // 参数校验
    
25.         if (min > max) (min, max) = (max, min);
    
26. 
    
27.         // 创建连续数字数组
    
28.         int length = max - min + 1;
    
29.         int[] numbers = new int[length];
    
30.         for (int i = 0; i < length; i++)
    
31.         {
    
32.             numbers[i] = min + i;
    
33.         }
    
34. 
    
35.         // 使用Fisher-Yates算法洗牌
    
36.         for (int i = length - 1; i > 0; i--)
    
37.         {
    
38.             int randomIndex = Random.Range(0, i + 1);
    
39.             // 交换元素
    
40.             int temp = numbers[i];
    
41.             numbers[i] = numbers[randomIndex];
    
42.             numbers[randomIndex] = temp;
    
43.         }
    
44. 
    
45.         return numbers;
    
46.     }
    
47. }

复制代码

2️⃣ 代码特点 特性 说明   无重复随机序列 生成 min 到 max 范围内的所有整数，且保证每个数字只出现一次  时间复杂度 O(n) 初始化数组 O(n) + 洗牌 O(n) = 总复杂度 O(n)  内存优化 直接操作数组，无需额外集合类  范围动态调整 支持任意整数范围（包括负数范围如 -5~5）
3️⃣ 两种典型应用场景 🔸 场景1：抽奖系统

1. // 生成1-10000的奖励ID并洗牌
   
2. int[] rewardIDs = GenerateShuffledRange(1, 10000);
   
3. 
   
4. // 按顺序发放奖励（保证不重复）
   
5. foreach(int id in rewardIDs)
   
6. {
   
7.     GiveReward(id);
   
8. }

复制代码

🔸 场景2：随机关卡顺序

1. // 生成0-9的关卡索引并洗牌
   
2. int[] levelOrder = GenerateShuffledRange(0, 9);
   
3. 
   
4. // 按洗牌后的顺序加载关卡
   
5. LoadLevel(levelOrder[currentIndex]);

复制代码

4️⃣ 与 Random.Range 的对比
Random.Range(0,100)        Shuffle 生成的数组
重复性        允许重复        保证所有值唯一
内存占用        无额外内存        需要存储整个数组
适用场景        单次随机值需求（如随机伤害）        需要不重复序列（如卡牌洗牌）
性能        O(1)        O(n)
5️⃣ 进阶用法：延迟生成 如果需要 动态获取随机数且避免重复，可以使用迭代器模式：

1. public class RandomSequenceGenerator
   
2. {
   
3.     private int[] _shuffledArray;
   
4.     private int _currentIndex;
   
5. 
   
6.     public RandomSequenceGenerator(int min, int max)
   
7.     {
   
8.         _shuffledArray = GenerateShuffledRange(min, max);
   
9.         _currentIndex = 0;
   
10.     }
    
11. 
    
12.     public int Next()
    
13.     {
    
14.         if (_currentIndex >= _shuffledArray.Length)
    
15.         {
    
16.             Debug.LogWarning("已到达序列末尾");
    
17.             return -1;
    
18.         }
    
19.         return _shuffledArray[_currentIndex++];
    
20.     }
    
21. }
    
22. 
    
23. // 使用示例
    
24. var generator = new RandomSequenceGenerator(0, 99);
    
25. Debug.Log(generator.Next()); // 输出第一个随机数
    
26. Debug.Log(generator.Next()); // 输出第二个随机数

复制代码

6️⃣ 数学原理 Fisher-Yates 洗牌算法通过以下步骤保证 均匀分布： 1.  从最后一个元素开始向前遍历  2.  每次随机选择一个 当前位置之前（包含当前位置） 的索引  3.  交换这两个位置的元素   通过这种操作，每个元素出现在每个位置的概率均等，最终生成的排列总数是 n!（n的阶乘），确保随机性质量。   如果需要 仅生成单个随机数 而不是序列，直接使用 Random.Range 即可，洗牌算法在这种场景下反而是性能浪费。务必根据实际需求选择最合适的随机方案。

admin

c# shuffle算法得出的数组，按照它们的下标顺序组合成一个整数。比如数组是[3,1,2]，下标0是3，1是1，2是2，组合成整数312
实现步骤
将数组元素转换为字符串：使用 string.Join 直接拼接数组元素。

字符串转整数：使用 int.Parse 或 int.TryParse 确保转换安全。

1. using System;
   
2. 
   
3. public class Program
   
4. {
   
5.     public static void Main()
   
6.     {
   
7.         int[] shuffledArray = {3, 1, 2};
   
8.         
   
9.         // 将数组元素拼接为字符串
   
10.         string combined = string.Join("", shuffledArray);
    
11.         
    
12.         // 转换为整数
    
13.         int result = int.Parse(combined);
    
14.         
    
15.         Console.WriteLine(result); // 输出：312
    
16.     }
    
17. }

复制代码

关键点说明
string.Join("", array)：
将数组元素直接拼接成一个连续字符串（例如 [3,1,2] → "312"），无需显式遍历数组。

int.Parse 的安全性问题：

如果数组可能包含非数字字符（如 ['a', 2]）或空数组，建议改用 int.TryParse 避免异常。

超大整数（超过 int 范围）需改用 long.Parse 或 BigInteger。
扩展场景
1. 处理多位数元素
如果数组元素是多位数（例如 [12, 34, 5] → 组合为 12345），上述代码仍然有效。

2. 安全转换（TryParse）

1. if (int.TryParse(combined, out int safeResult))
   
2. {
   
3.     Console.WriteLine(safeResult);
   
4. }
   
5. else
   
6. {
   
7.     Console.WriteLine("无效的整数格式");
   
8. }

复制代码

3. 数学方法（仅限元素为 0-9）
若数组元素均为 0-9 的数字，可用逐位计算：

1. int result = 0;
   
2. foreach (int digit in shuffledArray)
   
3. {
   
4.     result = result * 10 + digit;
   
5. }
   
6. Console.WriteLine(result); // 输出：312

复制代码

总结
字符串拼接法：通用性强，支持任意整数元素。

数学逐位法：仅适用于元素为 0-9 的情况，性能略高。

根据实际需求选择合适的方法即可。