洗牌算法

算法介绍

使用尽可能小的时间和空间，对一个数组进行随机乱序的操作。

实现思路

• 为了尽可能的节省内存，我选择在数组原地进行乱序
• 随机的实现可以用时间作为种子生成随机数

具体的实现思路很简单：首先在数组末尾设置一个指针hi，然后在0到hi之间随机一个索引，然后将这个索引指向的元素和hi交换，然后hi左移，往复上述操作，最终可以将数组完全打乱顺序。

代码实现

package shuffle

import (
	"math/rand"
	"time"
)

//本地洗牌
func Native(a []int) {
	seed := rand.NewSource(time.Now().Unix()) //获取当前时间当作随机数种子
	r := rand.New(seed)                       //设定随机数种子
	hi := len(a) - 1                          //定义一个指针只在数组最后
	for i := 0; i < len(a)-1; i++ {           //这里-1是因为最后一次循环只剩下一个元素，所以没必要循环了
		j := r.Intn(hi)
		//交换a[j]和a[hi]
		tmp := a[j]
		a[j] = a[hi]
		a[hi] = tmp
		hi--
	}
}

//返回一个新的洗牌后的数组
func New(a []int) []int {
	b := make([]int, len(a))
	copy(b, a)
	Native(b)
	return b
}

测试

编写一个测试脚本：

package main

import (
	"fmt"

	"./shuffle"
)

func main() {
	a := []int{1, 23, 4, 3, 56, 89, 74, 109, 35, 66}
	fmt.Println(a)
	shuffle.Native(a)
	fmt.Println(a)
}

多次执行，观察结果：

MacBook-Pro-2:洗牌算法 bbfat$ go run main.go 
[1 23 4 3 56 89 74 109 35 66]
[4 3 23 56 74 35 66 89 1 109]
MacBook-Pro-2:洗牌算法 bbfat$ go run main.go 
[1 23 4 3 56 89 74 109 35 66]
[66 3 89 74 4 1 109 35 56 23]
MacBook-Pro-2:洗牌算法 bbfat$ go run main.go 
[1 23 4 3 56 89 74 109 35 66]
[74 4 109 89 3 1 23 35 66 56]
MacBook-Pro-2:洗牌算法 bbfat$ go run main.go 
[1 23 4 3 56 89 74 109 35 66]
[35 109 1 56 74 3 23 66 89 4]
MacBook-Pro-2:洗牌算法 bbfat$ go run main.go 
[1 23 4 3 56 89 74 109 35 66]
[35 109 1 56 74 3 23 66 89 4]
MacBook-Pro-2:洗牌算法 bbfat$ go run main.go 
[1 23 4 3 56 89 74 109 35 66]
[66 74 23 35 4 109 1 3 56 89]

每一次输出的结果都是乱序的，算法可靠。

本节代码