面试官问：排序算法都有哪些？你写几个出来？

// 冒泡排序
func BubbleSort(arr []int){
    n := len(arr)
    for i:=0; i<n-1; i++{
        for j:=i+1; j<n; j++{
            if arr[i] > arr[j]{
                arr[i], arr[j] = arr[j], arr[i]
            }
        }
    }
    fmt.Println(arr)
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

// 改进的冒泡排序
func BubbleSort2(arr []int){
    n := len(arr)
    for i:=n-1; i>0; i--{    // 逆序遍历
        for j:=0; j<i; j++{
            if arr[j] > arr[j+1]{
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
    fmt.Println(arr)
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

// 选择排序
func SelectionSort(arr []int){
    n := len(arr)
    for i:=0; i<n-1; i++{
        minNumIndex := i    // 无序区第一个
        for j:=i+1; j<n; j++{
            if arr[j] < arr[minNumIndex]{
                minNumIndex = j
            }
        }
        arr[i], arr[minNumIndex] = arr[minNumIndex], arr[i]
    }
    fmt.Println(arr)
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

// 插入排序
func InsertionSort(arr []int){
    for i := range arr{
        preIndex := i-1
        current := arr[i]

        for preIndex >= 0 && arr[preIndex] > current{  // 移动
            arr[preIndex+1] = arr[preIndex]
            preIndex--
        }

        arr[preIndex+1] = current
    }
    fmt.Println(arr)
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

// 改进版插入排序
func InsertionSort2(arr []int){
    n := len(arr)
    for i:=1; i<n; i++{   // 无序区
        tmp := arr[i]
        left, right := 0, i-1
        for left<=right{
            mid := (left+right)/2
            if arr[mid] > tmp{
                right = mid-1
            }else{
                left = mid+1
            }
        }
        j:=i-1
        for ; j>=left; j--{   // 有序区
            arr[j+1] = arr[j]
        }
        arr[left] = tmp
    }
    fmt.Println(arr)
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

// 希尔排序
func ShellSort(arr []int){
    n := len(arr)
    for gap:=n/2; gap>=1; gap=gap/2{   // 缩小增量序列，希尔建议每次缩小一半
        for i:=gap; i<n; i++{       // 子序列
            tmp := arr[i]
            j:=i-gap
            for ; j>=0 && tmp<arr[j]; j=j-gap{
                arr[j+gap] = arr[j]
            }
            arr[j+gap] = tmp
        }
    }
    fmt.Println(arr)
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

// 归并排序--递归版
func MergeSort(arr []int) []int{
    n := len(arr)
    if n < 2{
        return arr
    }
    mid := n/2
    left := arr[:mid]
    right := arr[mid:]
    return merge(MergeSort(left), MergeSort(right))

}
func merge(left, right []int) []int{
    res := []int{}
    for len(left)!=0 && len(right)!=0{
        if left[0] <= right[0]{
            res = append(res, left[0])
            left = left[1:]     // 将头一个直接切出去
        }else {
            res = append(res, right[0])
            right = right[1:]
        }
    }
    if len(left) == 0{      // left结束，right剩下的直接拖下来
        res = append(res, right...)
    }
    if len(right) == 0{     // right结束，left剩下的直接拖下来
        res = append(res, left...)
    }
    return res
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.

// 归并排序--迭代版
func MergeSort2(arr []int) []int{
    n := len(arr)
    min := func(a, b int) int{
        if a < b{
            return a
        }
        return b
    }
    for step:=1; step<=n; step<<=1{     // 外层控制步长
        offset := 2*step
        for i:=0; i<n; i+=offset{       // 内层控制分组
            h2 := min(i+step, n-1)      // 第二段头部，防止超过数组长度
            tail2 := min(i+offset-1, n-1)   // 第二段尾部
            merge2(arr, i, h2, tail2)
        }
    }
    return arr
}

func merge2(arr []int, h1 int, h2 int, tail2 int){
    start := h1
    tail1 := h2-1   // 第一段尾部
    length := tail2-h1+1    // 两段长度和
    tmp := []int{}
    for h1 <= tail1 || h2 <= tail2{   // 其中一段未结束
        if h1 > tail1 {     // 第一段结束，处理第二段
            tmp = append(tmp, arr[h2])
            h2++
        }else if h2 > tail2{    // 第二段结束，处理第一段
            tmp = append(tmp, arr[h1])
            h1++
        }else {     // 两段都未结束
            if arr[h1] <= arr[h2]{
                tmp = append(tmp, arr[h1])
                h1++
            }else {
                tmp = append(tmp, arr[h2])
                h2++
            }
        }
    }

    for i:=0; i<length; i++{    // 将排序好两段合并写入arr
        arr[start+i] = tmp[i]
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.

func QuickSort(arr []int) []int{
    return _QuickSort(arr, 0, len(arr)-1)
}

func _QuickSort(arr []int, left int, right int) []int{
    if left < right{
        partitionIndex := Partition1Way(arr, left, right)
        // partitionIndex := Partition2Way(arr, left, right)
        _QuickSort(arr, left, partitionIndex-1)
        _QuickSort(arr, partitionIndex+1, right)
    }
    return arr
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

// 快速排序--单路
func Partition1Way(arr []int, left int, right int) int{
    // 先分区，最后把基准换到边界上
    privot := left
    index := privot + 1
    for i := index; i<=right; i++{
        if arr[privot] > arr[i]{  // 当前值小于基准就交换，大于的不用管
            arr[index], arr[i] = arr[i], arr[index]
            index++   // 交换后的下一个
        }
    }
    // arr[index]是大于基准的
    arr[privot], arr[index-1] = arr[index-1], arr[privot]
    return index-1
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

// 快速排序--双路版
func Partition2Way(arr []int, low int, high int) int{
    tmp := arr[low]     // 基准
    for low < high{
        // 当队尾的元素大于等于基准数据时,向前挪动high指针
        for low < high && arr[high] >= tmp{
            high--
        }
        // 如果队尾元素小于tmp了,需要将其赋值给low
        arr[low] = arr[high]
        // 当队首元素小于等于tmp时,向前挪动low指针
        for low < high && arr[low] <= tmp{
            low++
        }
        // 当队首元素大于tmp时,需要将其赋值给high
        arr[high] = arr[low]

    }
    // 跳出循环时low和high相等,此时的low或high就是tmp的正确索引位置
    // 由原理部分可以很清楚的知道low位置的值并不是tmp,所以需要将tmp赋值给arr[low]
    arr[low] = tmp
    return low
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

// 快速排序--三路
func QuickSort3Way(arr []int) []int{
    // 确定分区位置
    return _QuickSort3Way(arr, 0, len(arr)-1)
}
func _QuickSort3Way(arr []int, left int, right int) []int{
    if left < right{
        lo, gt := Partition3Way(arr, left, right)
        _QuickSort3Way(arr, left, lo-1)
        _QuickSort3Way(arr, gt, right)
    }
    return arr
}
func Partition3Way(arr []int, left, right int) (int, int){
    key := arr[left]
    lo, gt, cur := left, right+1, left+1  // lo和gt是相等区左右边界
    for cur < gt{
        if arr[cur] < key{  // 小于key，移到前面
            arr[cur], arr[lo+1] = arr[lo+1], arr[cur]   // lo+1,保证最后arr[lo]小于key
            lo++    // 左边界右移
            cur++   // 能够确定换完之后该位置值小于key,
        }else if arr[cur] > key{
            arr[cur], arr[gt-1] = arr[gt-1], arr[cur]
            gt--    // 从后面换到前面，不知道是否比key的大，还要再比一下，所以cur不移动
        }else {
            cur++
        }
    }
    arr[left], arr[lo] = arr[lo], arr[left]   // 最后移动基准，arr[lo]一定比key小
    return lo, gt
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.

// 堆排序
func HeapSort(arr []int) []int{
    arrLen := len(arr)
    BuildMaxHeap(arr, arrLen)   // 初始化大顶堆
    for i:=arrLen-1; i>=0; i--{
        swap(arr, 0, i)    // 交换根节点和最后一个节点
        arrLen--
        heapify(arr, 0, arrLen)
    }
    return arr
}

func BuildMaxHeap(arr []int, arrLen int){
    for i:=arrLen/2; i>=0; i--{
        heapify(arr, i, arrLen)
    }
}

func heapify(arr []int, i, arrLen int){
    left := 2*i+1       // 左子
    right := 2*i+2      // 右子
    largest := i        // 当前最大值位置
    if left<arrLen && arr[left]>arr[largest]{
        largest = left
    }
    if right<arrLen && arr[right]>arr[largest]{
        largest = right
    }
    if largest != i{
        swap(arr, i, largest)   // 交换
        heapify(arr, largest, arrLen)  // 调整二叉树
    }
}

func swap(arr []int, i, j int) {
    arr[i], arr[j] = arr[j], arr[i]
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.

// 计数排序
func CountingSort(arr []int) []int{
    length := len(arr)
    maxValue := getMaxValue(arr)
    bucketLen := maxValue+1
    bucket := make([]int, bucketLen)
    sortedIndex := 0
    // 统计每个元素出现的个数
    for i:=0; i<length; i++{
        bucket[arr[i]] += 1
    }
    // 按照统计结果写入arr
    for j:=0; j<length; j++{
        for bucket[j] > 0{
            arr[sortedIndex] = j   // bucket[j]的值是统计结果，后面会变化，j是真正值
            sortedIndex++
            bucket[j]--
        }
    }
    return arr
}
// 获得数组的最值差
func getMaxValue(arr []int) int{
    largest := math.MinInt32
    smallest := math.MaxInt32
    for i:=0; i<len(arr);i++{
        if arr[i] > largest{
            largest = arr[i]
        }
        if arr[i] < smallest{
            smallest = arr[i]
        }
    }
    maxValue := largest-smallest
    return maxValue
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.

// 桶排序
func BucketSort(arr []int, bucketSize int) []int{
    // 获得arr的最值
    length := len(arr)
    maxNum, minNum := arr[0], arr[0]
    for i:=0; i<length; i++{
        if arr[i]>maxNum{
            maxNum = arr[i]
        }else if arr[i]<minNum{
            minNum = arr[i]
        }
    }
    maxValue := maxNum - minNum
    // 初始化桶
    bucketNum := maxValue/bucketSize + 1  // 桶个数
    buckets := make([][]int, bucketNum)
    for i:=0; i<bucketNum; i++{
        buckets[i] = make([]int, 0)
    }
    // 利用映射将元素分配到每个桶中
    for i:=0; i<len(arr); i++{
        id := (arr[i]-minNum)/bucketSize   // 桶ID
        buckets[id] = append(buckets[id], arr[i])
    }
    // 对每个桶进行排序，然后按顺序将桶中数据放入arr
    arrIndex := 0
    for i:=0; i<bucketNum; i++{
        if len(buckets[i]) == 0{   // 空桶
            continue
        }
        InsertionSort2(buckets[i])    // 桶内排序
        for j:=0; j<len(buckets[i]); j++{   // 将每个桶的排序结果写入arr
            arr[arrIndex] = buckets[i][j]
            arrIndex++
        }
    }
    return arr
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.

// 基数排序
func RadixSort(arr []int, ) []int{
    maxn := maxBitNum(arr)      // arr最大位数
    dev := 1    // 除数，保证商最后一位是我们想要的
    mod := 10   // 模，取商的最后一位
    for i:=0; i<maxn; i++{      // 进行maxn次排序
        bucket := make([][]int, 10) // 定义10个空桶
        result := make([]int, 0)    // 存储中间结果
        for _, v := range arr{
            n := v / dev % mod  // 取出对应位的值，放入对应桶中
            bucket[n] = append(bucket[n], v)
        }
        dev *= 10
        // 按顺序存入中间数组
        for j:=0; j<10; j++{
            result = append(result, bucket[j]...)
        }
        // 转存到原数组（结果）
        for k := range arr{
            arr[k] = result[k]
        }
    }
    return arr
}
// 获取数组的最大位数
func maxBitNum(arr []int) int{
    ret := 1
    count := 10
    for i:=0; i<len(arr); i++{
        for arr[i]>count{   // 对arr变化会修改内存里的值
            count *= 10     // 所以这里对count进行放大
            ret++
        }
    }
    return ret
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.