作为一个小项目，我已经使用Go编写了一些著名的排序算法。希望对你有用！

冒泡排序

冒泡排序是一种非常容易遵循的算法。你需要遍历数组中的每个元素，以查看它是否更大，如果需要，则需要交换它们。你应该多次执行此任务，最终将不需要任何交换操作，也就是完成了排序。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package main
import "fmt"
func main() {
    var n = []int{1, 39, 2, 9, 7, 54, 11}
    var isDone = false
    for !isDone {
        isDone = true
        var i = 0
        for i < len(n) - 1 {
            if n[i] > n[i + 1] {
                var temp = n[i]
                n[i] = n[i + 1]
                n[i + 1] = temp
                isDone = false
            }
            i++
        }
    }
    fmt.Println(n)
}

插入排序

插入排序是一种著名的排序算法，其工作方式类似于对一副纸牌进行排序。当你遍历数组的各个元素时，可以将其移回正确的位置。

插入排序

（版权所有：https://www.geeksforgeeks.org/)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main
import "fmt"
func main() {
    var n = []int{1, 39, 2, 9, 7, 54, 11}
    var i = 1
    for i < len(n) {
        var j = i
        for j >= 1 && n[j] < n[j - 1] {
            var temp = n[j]
            n[j] = n[j - 1]
            n[j - 1] = temp
            j--
        }
        i++
    }
    fmt.Println(n)
}

选择排序

选择排序很有趣，但很简单。你需要做的就是简单地将迭代中的当前元素替换为右侧的最小值。这样左侧部分就是排好序的，然后不停的迭代选择，直达最后一个元素。

选择排序 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main
import "fmt"
func main() {
    var n = []int{1, 39, 2, 9, 7, 54, 11}
    var i = 1
    for i < len(n) - 1 {
        var j = i + 1
        var minIndex = i
        if j < len(n) {
            if n[j] < n[minIndex] {
                minIndex = j
            }
            j++
        }
        if minIndex != i {
            var temp = n[i]
            n[i] = n[minIndex]
            n[minIndex] = temp
        }
        i++
    }
    fmt.Println(n)
}

归并排序

归并排序是一种非常快速的排序算法。在归并排序中，实用的是分而治之的做法。首先，将递归的把数组对半分，直到最后达到1的长度，然后合并它们。要合并两个我们已经对其进行排序的数组，可以实现一个简单的函数，称为merge。

归并排序 

 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

package main
import "fmt"
func merge(fp []int, sp []int) []int {
    var n = make([]int, len(fp)+len(sp))
    var fpIndex = 0
    var spIndex = 0
    var nIndex = 0
    for fpIndex < len(fp) && spIndex < len(sp) {
        if fp[fpIndex] < sp[spIndex] {
            n[nIndex] = fp[fpIndex]
            fpIndex++
        } else if sp[spIndex] < fp[fpIndex] {
            n[nIndex] = sp[spIndex]
            spIndex++
        }
        nIndex++
    }
    for fpIndex < len(fp) {
        n[nIndex] = fp[fpIndex]
        fpIndex++
        nIndex++
    }
    for spIndex < len(sp) {
        n[nIndex] = sp[spIndex]
        spIndex++
        nIndex++
    }
    return n
}
func mergeSort(arr []int) []int {
    if len(arr) == 1 {
        return arr
    }
    var fp = mergeSort(arr[0 : len(arr)/2])
    var sp = mergeSort(arr[len(arr)/2:])
    return merge(fp, sp)
}
func main() {
    var n = []int{1, 39, 2, 9, 7, 54, 11, 8}
    fmt.Println(mergeSort(n))
}

转自： https://dev.to/adnanbabakan/sorting-algorithms-in-go-725

本文原创译文文章，转载注明出处,欢迎扫码关注公众号flysnow_org或者网站 https://www.flysnow.org/ ，第一时间看后续精彩文章。觉得好的话，请顺手点个赞吧。

扫码关注