脚本怎样随机打乱列表顺序

本文目录导读：

1. Python
2. JavaScript
3. Java
4. C
5. Bash/Linux
6. 推荐的洗牌算法解释
7. 注意事项

Python

import random
# 方法1：使用 random.shuffle（原地打乱）
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
random.shuffle(my_list)
print(my_list)
# 方法2：使用 random.sample（返回新列表）
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
shuffled_list = random.sample(my_list, len(my_list))
print(shuffled_list)

JavaScript

// 方法1：Fisher-Yates 洗牌算法（推荐）
function shuffle(array) {
    const arr = [...array];
    for (let i = arr.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [arr[i], arr[j]] = [arr[j], arr[i]];
    }
    return arr;
}
const myList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const shuffledList = shuffle(myList);
console.log(shuffledList);
// 方法2：使用 sort + random（不够均匀，不推荐）
const badShuffle = [...myList].sort(() => Math.random() - 0.5);

Java

import java.util.*;
public class ShuffleExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
        Collections.shuffle(list);
        System.out.println(list);
        // 使用自定义随机种子
        Collections.shuffle(list, new Random(42));
    }
}

C

using System;
using System.Linq;
using System.Collections.Generic;
class Program {
    static void Main() {
        List<int> list = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        // 方法1：Fisher-Yates 洗牌算法
        Random rand = new Random();
        for (int i = list.Count - 1; i > 0; i--) {
            int j = rand.Next(i + 1);
            int temp = list[i];
            list[i] = list[j];
            list[j] = temp;
        }
        // 方法2：使用 LINQ 和 OrderBy
        var shuffled = list.OrderBy(x => Guid.NewGuid()).ToList();
        Console.WriteLine(string.Join(", ", list));
    }
}

Bash/Linux

# 方法1：使用 shuf 命令
my_list=(1 2 3 4 5 6 7 8 9 10)
shuffled=($(shuf -e "${my_list[@]}"))
echo "${shuffled[@]}"
# 方法2：使用 sort -R（需要 GNU sort）
shuffled=($(printf '%s\n' "${my_list[@]}" | sort -R))

推荐的洗牌算法解释

Fisher-Yates 算法（也称为 Knuth 洗牌）是最推荐的打乱算法：

def fisher_yates_shuffle(arr):
    for i in range(len(arr) - 1, 0, -1):
        j = random.randint(0, i)  # 随机选择 0 到 i 之间的索引
        arr[i], arr[j] = arr[j], arr[i]  # 交换元素
    return arr

算法原理：

• 从最后一个元素开始
• 随机选择当前元素之前（包括自身）的一个位置
• 交换这两个位置的元素
• 向前移动到下一个位置，重复直到第一个元素

优点：

• 时间复杂度 O(n)
• 每次洗牌结果都是等概率的（真正的随机）
• 原地操作，不需要额外空间

注意事项

1. 不要使用 arr.sort(() => Math.random() - 0.5)：虽然简单，但不会产生均匀分布
2. 随机种子：测试时可以使用固定种子确保可重复性
3. 线程安全：多线程环境下注意随机数生成器的线程安全