# go语言十大排序算法总结

## 选择排序

```package mainimport (    "fmt")type SortInterface interface {
sort()
}type Sortor struct {
name string}func main() {
arry := []int{6, 1, 3, 5, 8, 4, 2, 0, 9, 7}
learnsort := Sortor{name: "选择排序--从小到大--不稳定--n*n---"}
learnsort.sort(arry)

fmt.Println(learnsort.name, arry)
}func (sorter Sortor) sort(arry []int) {
arrylength := len(arry)    for i := 0; i < arrylength; i++ {
min := i        for j := i + 1; j < arrylength; j++ {            if arry[j] < arry[min] {
min = j
}
}
t := arry[i]
arry[i] = arry[min]
arry[min] = t

}
}```

`/usr/local/go/bin/go build -i [/Users/liuhanlin/GO/src/go_learn]成功: 进程退出代码 0./Users/liuhanlin/GO/src/go_learn/go_learn  [/Users/liuhanlin/GO/src/go_learn]选择排序--从小到大--不稳定--n*n--- [0 1 2 3 4 5 6 7 8 9]成功: 进程退出代码 0.`

## 冒泡排序

```package mainimport (    "fmt")type SortInterface interface {
sort()
}type Sortor struct {
name string}func main() {
arry := []int{6, 1, 3, 5, 8, 4, 2, 0, 9, 7}
learnsort := Sortor{name: "冒泡排序--从小到大--稳定--n*n---"}
learnsort.sort(arry)
fmt.Println(learnsort.name, arry)
}func (sorter Sortor) sort(arry []int) {
done := true
arrylength := len(arry)    for i := 0; i < arrylength && done; i++ {
done = false
for j := 0; j < arrylength-i-1; j++ {
done = true
if arry[j] > arry[j+1] {
t := arry[j]
arry[j] = arry[j+1]
arry[j+1] = t
}
}

}
}```

`/usr/local/go/bin/go build -i [/Users/liuhanlin/GO/src/go_learn]成功: 进程退出代码 0./Users/liuhanlin/GO/src/go_learn/go_learn  [/Users/liuhanlin/GO/src/go_learn]冒泡排序--从小到大--稳定--n*n--- [0 1 2 3 4 5 6 7 8 9]成功: 进程退出代码 0.`

## 快速排序

```package mainimport (    "fmt")type SortInterface interface {
sort()
}type Sortor struct {
name string}func main() {
arry := []int{6, 1, 3, 5, 8, 4, 2, 0, 9, 7}
learnsort := Sortor{name: "快速排序--从小到大--不稳定--nlog2n最坏n＊n---"}
learnsort.sort(arry)
fmt.Println(learnsort.name, arry)
}func (sorter Sortor) sort(arry []int) {    if len(arry) <= 1 {        return //递归终止条件，slice变为0为止。
}
mid := arry[0]
i := 1 //arry[0]为中间值mid，所以要从1开始比较
head, tail := 0, len(arry)-1
for head < tail {        if arry[i] > mid {
arry[i], arry[tail] = arry[tail], arry[i] //go中快速交换变量值，不需要中间变量temp
tail--
} else {
arry[i], arry[head] = arry[head], arry[i]
head++
i++
}
}
arry[head] = mid
sorter.sort(arry[:head]) //这里的head就是中间值。左边是比它小的，右边是比它大的，开始递归。
sorter.sort(arry[head+1:])

}```

`/usr/local/go/bin/go build -i [/Users/liuhanlin/GO/src/go_learn]成功: 进程退出代码 0./Users/liuhanlin/GO/src/go_learn/go_learn  [/Users/liuhanlin/GO/src/go_learn]快速排序--从小到大--不稳定--nlog2n最坏n＊n--- [0 1 2 3 4 5 6 7 8 9]成功: 进程退出代码 0.`

## 插入排序

```package mainimport (    "fmt")type SortInterface interface {
sort()
}type Sortor struct {
name string}func main() {
arry := []int{6, 1, 3, 5, 8, 4, 2, 0, 9, 7}
learnsort := Sortor{name: "插入排序--从小到大--稳定--n＊n---"}
learnsort.sort(arry)
fmt.Println(learnsort.name, arry)
}func (sorter Sortor) sort(arry []int) {
arrylength := len(arry)    for i, j := 1, 0; i < arrylength; i++ { //i从1开始，就是要插入的值。之所以从1开始，其实是要对挪窝做准备。因为接下来，我要对前面排好序的数据，依次挪窝。
temp := arry[i]                             //temp为开始排序的位置，从1开始。也是
for j = i; j > 0 && arry[j-1] > temp; j-- { //每次都从外层循环的计数器开始，跟一个temp变量比较，大的话，就往前挪一个窝。
//因为前面都是排序好的，所以是依次挪窝。不会有数据丢失.
arry[j] = arry[j-1]
}
arry[j] = temp //最后将挪出来的恰当位置给这个temp变量。也就是每次要插入的值。

}
}```

`/usr/local/go/bin/go build -i [/Users/liuhanlin/GO/src/go_learn]成功: 进程退出代码 0./Users/liuhanlin/GO/src/go_learn/go_learn  [/Users/liuhanlin/GO/src/go_learn]插入排序--从小到大--稳定--n＊n--- [0 1 2 3 4 5 6 7 8 9]成功: 进程退出代码 0.`

1782 篇文章407 人订阅

0 条评论

## 相关文章

15550

### .Net CSharp语言中When关键字的用法

c# 6引入了when关键字。when关键字是通过某些特定标准来过滤catch块中的异常的一种方法。后来在c# 7中扩展到case语句。我们将介绍如何在异常处理...

14000

24310

### 设计模式——模板方法模式

●　1.定义了一个或多个抽象操作，以便让子类实现。这些抽象操作叫做基本操作，它们是一个顶级逻辑的组成步骤。

9910

28840

44260

### C语言之预处理命令与用typedef命名已有类型

预处理命令 主要是改进程序设计环境，以提高编程效率，不属于c语言本身的组成部分，不能直接对它们进行编译，必须在对 程序编译之前，先对程序中的这些特殊命令进行...

43090

11610

27780

14520