原文：https://blog.csdn.net/qq_43279457/article/details/121730095
一、整型
首先用下里面提供的最简单的例子，排序一下整形
package main
import (
"fmt"
"sort"
)
func main() {
a := sort.IntSlice{2, 8, 3, 7, 9, 4, 1, 6}
fmt.Println("排序前", a)
sort.Sort(a)
fmt.Println("排序后", a)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
你最好奇的应该是 sort.IntSlice 这个是什么东西。点进去查看源码，可以看到它是 []int 类型并绑定了四个方法，前三个是对排序的对象必须得拥有的（也就是说如果自己想对一个对象排序时，必须实现这些方法），但sort包已经给我们实现了。然后还绑定了一个 Sort() 方法
基于这些信息，我们就可以改造一下前面的示例，直接调用该对象里面绑定的 Sort() 方法，而不是使用sort包中提供的 Sort() 方法，结果不变。
func main() {
a := sort.IntSlice{2, 8, 3, 7, 9, 4, 1, 6}
fmt.Println("排序前", a)
// sort.Sort(a)
a.Sort()
fmt.Println("排序后", a)
}
1
2
3
4
5
6
7
如果我们不使用里面的提供的 sort.IntSlice 类型，而是自己实现一个，怎么写，直接复制里面 IntSlice 的实现，然后换一个名字即可【苦笑.jpg】
package main
import (
"fmt"
"sort"
)
type paixua []int
func (x paixua) Len() int {
return len(x)
}
func (x paixua) Less(i, j int) bool {
return x[i] < x[j]
}
func (x paixua) Swap(i, j int) {
x[i], x[j] = x[j], x[i]
}
func (x paixua) Sort() {
sort.Sort(x)
}
func main() {
a := paixua{2, 8, 3, 7, 9, 4, 1, 6}
fmt.Println("排序前", a)
a.Sort()
fmt.Println("排序后", a)
}
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
里面的三个方法的作用是什么？
Len()：返回切片的长度
Less()：两个值比较结果的布尔值
Swap()：用于交换两个值
一般我们要修改的只是 Less() 方法，因为可以看到前面排序都是升序排序，将里面的小于号改成大于号，就是降序排序了
后面还有方法实现倒序，而不用自己修改
那它里面使用的是什么排序算法实现的？
看源码，如下图，可以发现使用的是 quickSort 快速排序算法
有趣的是，看上图中后面那里，发现 Ints、Float64s、Strings。其实又是一种封装，用法更简单了一些，如下
func main() {
a := []int{5, 2, 7, 6, 4, 1, 3, 9}
fmt.Println("排序前", a)
sort.Ints(a)
fmt.Println("排序后", a)
}
1
2
3
4
5
6
同时你也发现里面还有 IntsAreSorted、Float64sAreSorted、StringsAreSorted。他就是返回一个切片是否已经是升序排序好了的布尔值，个人觉得比较鸡肋。
倒序
同时还能发现 Reverse 这个方法，用于倒序，用法如下
func main() {
a := []int{2, 8, 3, 7, 9, 4, 1, 6}
fmt.Println("排序前", a)
sort.Sort(sort.Reverse(sort.IntSlice(a)))
fmt.Println("排序后", a)
}
1
2
3
4
5
6
懂了整形的排序之后，就很容易懂其他类型的排序，如浮点、字符串
二、浮点型
三、字符串型
可以发现字符串根据首字母来排序，如果相同再根据相同的两个数的第二位排序，区分大小写，大写排前面，符合ascall码的规则
四、真的使用的是快速排序算法吗？
查找sort包中的排序算法，发现有四个
insertionSort：插入排序
heapSort：堆排序
quickSort：快速排序
symMerge：归并排序
回到 quickSort 方法中，发现它会自动选择使用排序算法
五、稳定性
包中也说明使用 sort.Sort() 不是稳定的
要想稳定，得使用 Stable() 函数
可以使用 sort.IntSlice{} 的方法实现
也可以使用自定义的方法实现
但是不能使用 sort.Ints() 的方法实现，因为里面使用的是 sort.Sort()
// 这里使用自定义的方式实现
package main
import (
"fmt"
"sort"
)
type paixua []int
func (x paixua) Len() int {
return len(x)
}
func (x paixua) Less(i, j int) bool {
return x[i] < x[j]
}
func (x paixua) Swap(i, j int) {
x[i], x[j] = x[j], x[i]
}
func main() {
a := paixua{2, 8, 3, 7, 9, 4, 1, 6}
fmt.Println("排序前", a)
sort.Stable(a)
fmt.Println("排序后", a)
}
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
六、结构体类型排序
sort包中并没有提供 struct 类型的排序，但是你不觉得 type paixuArr []paixu 和 type paixu []int 是一样的吗？
package main
import (
"fmt"
"sort"
)
type paixu struct {
Name string
Id int
}
type paixuArr []paixu
func (x paixuArr) Len() int {
return len(x)
}
func (x paixuArr) Less(i, j int) bool {
return x[i].Id < x[j].Id
}
func (x paixuArr) Swap(i, j int) {
x[i], x[j] = x[j], x[i]
}
func NewObj() paixuArr {
return paixuArr{
{"a", 3},
{"b", 1},
{"c", 4},
{"d", 2},
}
}
func main() {
a := NewObj() // 初始化数据
fmt.Println("排序前", a)
sort.Sort(a)
fmt.Println("排序后", a)
}
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