基本排序算法Golang

時間 2019-12-09

標籤基本排序算法 golang 欄目 Go 简体版

原文原文鏈接

摘要算法

排序有內部排序和外部排序，內部排序是數據記錄在內存中進行排序，而外部排序是因排序的數據很大，一次不能容納所有的排序記錄，在排序過程當中須要訪問外存。

冒泡排序ui

 1 func BubbleSort(vector []int) {
 2     fmt.Println("BubbleSort")
 3     fmt.Println(vector)
 4     for i := 0; i < len(vector); i++ {
 5         tag := true // 爲了剪枝
 6         // 每一趟將最大的數冒泡
 7         for j := 0; j < len(vector)-i-1; j++ {
 8             if vector[j] > vector[j+1] { /*vector[j] < vector[j+1]*/
 9                 temp := vector[j]
10                 vector[j] = vector[j+1]
11                 vector[j+1] = temp
12                 tag = false
13             }
14         }
15         if tag {
16             break //0~len(vector)-i沒有發生交換說明已經有序
17         }
18         fmt.Println(vector)
19     }
20 }

插入排序spa

 1 func InsertSort(vector []int) {
 2     fmt.Println("InsertSort")
 3     fmt.Println(vector)
 4     for i := 1; i < len(vector); i++ {
 5         // 每一趟不知足條件就選擇i爲哨兵保存，將哨兵插入0~i-1有序序列（0~i-1始終是有序的）
 6         if vector[i] < vector[i-1] { /*vector[i] > vector[i-1]*/
 7             temp := vector[i]
 8             //後移直到找到哨兵合適的位置
 9             j := i - 1
10             for ; j >= 0 && vector[j] > temp; j-- { /*vector[j] < temp*/
11                 vector[j+1] = vector[j]
12             }
13             //插入位置先後都是有序的，最後也是有序的
14             vector[j+1] = temp
15         }
16         fmt.Println(vector)
17     }
18 }

選擇排序code

 1 func SelectSort(vector []int) {
 2     fmt.Println("SelectSort")
 3     fmt.Println(vector)
 4     for i := 0; i < len(vector); i++ {
 5         // 選擇最小的元素
 6         k := i
 7         for j := i + 1; j < len(vector); j++ {
 8             if vector[k] > vector[j] {
 9                 k = j
10             }
11         }
12         // 交換
13         if k != i {
14             temp := vector[i]
15             vector[i] = vector[k]
16             vector[k] = temp
17         }
18         fmt.Println(vector)
19     }
20 }

二元選擇排序blog

 1 func BinarySelectSort(vector []int) {
 2     fmt.Println("SelectSort")
 3     fmt.Println(vector)
 4     n := len(vector)
 5     for i := 0; i < n/2; i++ {
 6         // 選擇最小的元素和最大元素
 7         k := i
 8         t := n - i - 1
 9         for j := i + 1; j <= n-i-1; j++ {
10             if vector[k] > vector[j] {
11                 k = j
12             }
13             if vector[t] < vector[j] {
14                 t = j
15             }
16         }
17         // 交換
18         if k != i {
19             temp := vector[i]
20             vector[i] = vector[k]
21             vector[k] = temp
22         }
23         if t != n-i-1 {
24             temp := vector[n-i-1]
25             vector[n-i-1] = vector[t]
26             vector[t] = temp
27         }
28         fmt.Println(vector)
29     }
30 }

快速排序排序

簡單的說快速排序就是挖坑填數而後分治，公認效率最好，這個必須會
遞歸

 1 func QuickSort(vector []int, low, hight int) {
 2     fmt.Println(vector)
 3     if low < hight {
 4         i := low
 5         j := hight
 6         temp := vector[low] // 開始挖坑填數
 7         for i < j {
 8             for i < j && vector[j] >= temp {
 9                 j--
10             }
11             vector[i] = vector[j]
12             for i < j && vector[i] <= temp {
13                 i++
14             }
15             vector[j] = vector[i]
16         }
17         vector[i] = temp
18         QuickSort(vector, low, i-1) // 分治
19         QuickSort(vector, i+1, hight)
20     }
21 }