Golang实现常用排序算法

Posted 2022-01-03 ly570

主函数
package main

import (
"fmt"
"math/rand"
"sort"
"time"
)

const (
num = 10000 // 测试数组的长度
rangeNum = 100000 // 数组元素大小范围
)
func main()
arr := GenerateRand()//生成随机数组
//排序前 复制原数组
org_arr := make([]int, num)
copy(org_arr, arr)
//冒泡排序
//Bubble(arr)
// 选择排序
//SelectSort(arr)
// 插入排序
//InsertSort(arr)
//快速排序
//QuickSort(arr, 0, len(arr)-1)
// 归并排序
//MergeSort(arr, 0, len(arr)-1)
// 堆排序
//HeapSort(arr)
sort.Ints(org_arr) //使sort模块对原数组排序
//fmt.Println(arr, org_arr, IsSame(arr, org_arr))
//打印前15个数,并对比排序是否正确
fmt.Println(arr[:15], org_arr[:15], IsSame(arr, org_arr))

//生成随机数组
func GenerateRand() []int
randSeed := rand.New(rand.NewSource(time.Now().Unix() + time.Now().UnixNano()))
arr := make([]int, num)
for i := 0; i < num; i++
arr[i] = randSeed.Intn(rangeNum)

return arr

//比较两个切片
func IsSame(slice1, slice2 []int) bool
if len(slice1) != len(slice2)
return false

if (slice1 == nil) != (slice2 == nil)
return false

for i, num := range slice1
if num != slice2[i]
return false


return true

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
冒泡排序
func Bubble(arr []int)
size := len(arr)
var swapped bool
for i := size - 1; i > 0; i--
swapped = false
for j := 0; j < i; j++
if arr[j+1] < arr[j]
arr[j], arr[j+1] = arr[j+1], arr[j]
swapped = true


if swapped != true
break

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
选择排序
func SelectSort(arr []int)
for i := 0; i < len(arr)-1; i++
for j := i + 1; j <= len(arr)-1; j++
if arr[j] < arr[i]
arr[j], arr[i] = arr[i], arr[j]




1
2
3
4
5
6
7
8
9
插入排序
func InsertSort(arr []int)
for i := 1; i <= len(arr)-1; i++
for j := i; j > 0; j--
if arr[j-1] > arr[j]
arr[j-1], arr[j] = arr[j], arr[j-1]




1
2
3
4
5
6
7
8
9
快速排序
func QuickSort(arr []int, l, r int)
if l < r
pivot := arr[http://www.my516.com]
i := l - 1
for j := l; j < r; j++
if arr[j] <= pivot
i++
arr[j], arr[i] = arr[i], arr[j]


i++
arr[r], arr[i] = arr[i], arr[r]
QuickSort(arr, l, i-1)
QuickSort(arr, i+1, r)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
归并排序
//合并
func Merge(arr []int, l, mid, r int)
// 分别复制左右子数组
n1, n2 := mid-l+1, r-mid
left, right := make([]int, n1), make([]int, n2)
copy(left, arr[l:mid+1])
copy(right, arr[mid+1:r+1])
i, j := 0, 0
k := l
for ; i < n1 && j < n2; k++
if left[i] <= right[j]
arr[k] = left[i]
i++
else
arr[k] = right[j]
j++


for ; i < n1; i++
arr[k] = left[i]
k++

for ; j < n2; j++
arr[k] = right[j]
k++

//分治
func MergeSort(arr []int, l, r int)
if l < r
mid := (l + r - 1) / 2
MergeSort(arr, l, mid)
MergeSort(arr, mid+1, r)
Merge(arr, l, mid, r)


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 adjust_heap(arr []int, i, size int)
if i <= (size-2)/2
//左右子节点
l, r := 2*i+1, 2*i+2
m := i
if l < size && arr[l] > arr[m]
m = l

if r < size && arr[r] > arr[m]
m = r

if m != i
arr[m], arr[i] = arr[i], arr[m]
adjust_heap(arr, m, size)

//建堆
func build_heap(arr []int)
size := len(arr)
//从最后一个子节点开始向前调整
for i := (size - 2) / 2; i >= 0; i--
adjust_heap(arr, i, size)

func HeapSort(arr []int)
size := len(arr)
build_heap(arr)
for i := size - 1; i > 0; i--
//顶部arr[0]为当前最大值,调整到数组末尾
arr[0], arr[i] = arr[i], arr[0]
adjust_heap(arr, 0, i)

---------------------