GoLang 四大经典排序(冒泡排序,选择排序,插入排序,快速排序)写法及执行效率

  • 冒泡排序

　　

 

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "math/rand"
 6     "time"
 7 )
 8 
 9 //BubbleSort 冒泡排序
10 func BubbleSort(arr *[10]int) {
11     for i := 0; i < len(arr)-1; i++ {
12         for j := 0; j < len(arr)-1-i; j++ {
13             if arr[j] > arr[j+1] {
14                 // t := arr[j]
15                 // arr[j] = arr[j+1]
16                 // arr[j+1] = t
17 
18                 arr[j], arr[j+1] = arr[j+1], arr[j]
19 
20             }
21 
22         }
23         fmt.Printf("第%v 次 排序后arr: %v\n", i+1, *arr)
24     }
25 }
26 
27 //GetRandomNum 获取随机数
28 func GetRandomNum() [10]int {
29 
30     countNum := 0
31     var num [10]int
32     rand.Seed(time.Now().UnixNano())
33     for i := 0; i < 10; i++ {
34         r := rand.Intn(100) + 1
35         num[i] = r
36         countNum++
37     }
38     fmt.Printf("一共生成 %v 个 随机数\n", countNum)
39     return num
40 }
41 
42 func main() {
43     arr := GetRandomNum()
44 
45     fmt.Printf("冒泡排序前的数组:%v\n", arr)
46     fmt.Println()
47     fmt.Println("开始排序...")
48     BubbleSort(&arr)
49     fmt.Println("结束排序...")
50     fmt.Println()
51     fmt.Printf("冒泡排序后的数组:%v\n", arr)
52 }
冒泡排序案例

 

 

  • 选择排序

 

 1 package main
 2 
 3 import "fmt"
 4 
 5 //SelectSort 选择排序
 6 func SelectSort(arr *[10]int) {
 7     for j := 0; j < len(arr)-1; j++ {
 8         max := arr[j]
 9         maxIndex := j
10         for i := j + 1; i < len(arr); i++ {
11             if max < arr[i] {
12                 //记录
13                 max = arr[i]
14                 maxIndex = i
15             }
16         }
17         //交换
18         if maxIndex != j {
19             arr[j], arr[maxIndex] = arr[maxIndex], arr[j]
20         }
21         fmt.Printf("数据第 %v 次交换后为:\t%v\n", j+1, *arr)
22     }
23 }
24 
25 func main() {
26     arr := [10]int{10, 9, 15, 55, 67, 77, 25, 350, 99, 100}
27     fmt.Printf("排序前数组:\t\t%v\n", arr)
28     fmt.Println()
29     SelectSort(&arr)
30     fmt.Println()
31     fmt.Printf("排序后数组:\t\t%v\n", arr)
32 
33 }
选择排序案例

 

 

  • 插入排序

 

 1 package main
 2 
 3 import "fmt"
 4 
 5 //InsertSort 插入排序
 6 func InsertSort(arr *[10]int) {
 7     for i := 1; i < len(arr); i++ {
 8         insertVal := arr[i]
 9         insertIndex := i - 1
10 
11         /* 从大到小 */
12         for insertIndex >= 0 && arr[insertIndex] < insertVal {
13             //数据后移
14             arr[insertIndex+1] = arr[insertIndex]
15             insertIndex--
16         }
17         /* 插入数据 */
18         if insertIndex+1 != i {
19             arr[insertIndex+1] = insertVal
20         }
21 
22         fmt.Printf("第 %v 次插入数据后:\t%v\n", i, *arr)
23     }
24 }
25 
26 func main() {
27 
28     arr := [10]int{10, 9, 15, 55, 67, 77, 25, 350, 99, 100}
29     fmt.Printf("原数据:\t\t\t%v\n", arr)
30     fmt.Println()
31     InsertSort(&arr)
32     fmt.Println()
33     fmt.Printf("插入排序后:\t\t%v\n", arr)
34 }
插入排序案例

 

 

  • 快速排序(递归算法) 

 

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "math/rand"
 6     "time"
 7 )
 8 
 9 //GetRandomNum 获取随机数
10 func GetRandomNum() [66]int {
11 
12     countNum := 0
13     var num [66]int
14     rand.Seed(time.Now().UnixNano())
15     for i := 0; i < 66; i++ {
16         r := rand.Intn(1000) + 1
17         num[i] = r
18         countNum++
19     }
20     fmt.Printf("一共生成 %v 个 随机数\n", countNum)
21     return num
22 }
23 
24 //QuickSort 快速排序
25 func QuickSort(left int, right int, array *[66]int) {
26 
27     l := left                       //数组左边数据下标
28     r := right                      //数组右边数据下标
29     center := array[(left+right)/2] //数组中间数据下标
30     t := 0                          //临时变量
31     for l < r {
32         /* 可改变< > 若l > r 就改 < ,否则反之*/
33         for array[l] < center {
34             l++
35         }
36 
37         /* 可改变< > */
38         for array[r] > center {
39             r--
40         }
41         if l >= r {
42             break
43         }
44         t = array[l]
45         array[l] = array[r]
46         array[r] = t
47         if array[l] == center {
48             r--
49         }
50         if array[r] == center {
51             l++
52         }
53     }
54 
55     /* 不加这个判断,就成死循环,无限递归 */
56     if l == r {
57         l++
58         r--
59     }
60 
61     /* 向左递归 */
62     if left < r {
63         QuickSort(left, r, array)
64     }
65     /* 向右递归 */
66     if right > l {
67         QuickSort(l, right, array)
68     }
69 }
70 func main() {
71     start := time.Now().Unix()
72     end := time.Now().Unix()
73 
74     fmt.Println("开始排序...")
75     num := GetRandomNum()
76     //fmt.Println("排序前数组:", num)
77     fmt.Println()
78     QuickSort(0, len(num)-1, &num)
79     fmt.Println()
80     for i := 0; i < len(num); i++ {
81         fmt.Printf("排序后数组:\t%v\t\t\t\t\t\t\n", num[i])
82     }
83 
84     fmt.Println("结束排序...")
85     fmt.Printf("快速排序计算66个数字一共耗时 %v 秒", end-start)
86 }
快速排序

 

 

  • 速度测试:

  • [ 注:统计时间根据电脑硬件配置不同,结果会有差异 ]

  • 创建一个获取随机数函数,生成100W个(1-1000)的随机数,

  • 分别让冒泡排序,选择排序,插入排序,快速排序 进行排序,并统计消耗时间

 

 1 //GetRandomNum 获取随机数
 2 func GetRandomNum() [1000000]int {
 3 
 4     countNum := 0
 5     var num [1000000]int
 6     rand.Seed(time.Now().UnixNano())
 7     for i := 0; i < 1000000; i++ {
 8         r := rand.Intn(1000) + 1
 9         num[i] = r
10         countNum++
11     }
12     fmt.Printf("一共生成 %v 个 随机数\n", countNum)
13     return num
14 }

 

 

 

  • 耗时统计结果:
  • 冒泡排序(100W个随机数)

  •  

  • 选择排序(100W个随机数)
  • 插入排序  (100W个随机数)

 

 

 

  • 快速排序(由于速度太快,故将数据提升至5000W)

  •  

     

  • 测试结果(执行效率从快到慢) :
  • 快速排序  >  插入排序  > 选择排序  >  冒泡排序 

 

posted @ 2020-12-22 16:02  伊凡晴天  阅读(416)  评论(0)  编辑  收藏  举报