Go 1.19.4 Sort排序进阶-Day 12

1. 结构体（切片）排序

结构体返回的是切片。

之前学习了sort.Ints()和sort.Strings()，使用这两个sort库下面的方法，可以对int和strings进行排序。

那如果我要对自定义类型进行排序，怎么办，sort库没提供，怎么办？可以参照sort源码自己写一个。

1.1 sort源码解析

一个需要排序的类型，必须要实现下面接口中的3个方法。
type Interface interface {

    Len() int // 能取长度，不管有多少元素，也不管是什么数据类型

    Less(i, j int) bool // 可以取索引，比较大小

    Swap(i, j int) // 交换i与j的索引位置
}

对于切片来说，Len和Swap都还好处理，难点就在于Less的比较大小。
任意类型或者自定义的类型，如何使用Less进行大小比较呢？我也没有办法提前知道，这个切片中，到底会存放什么类型的元素。

1.1.1 sort.Ints源码解析

sort.Ints()，ctrl+鼠标左键点击ints，会跳转到sort.go，然后会有这样一行代码：

func Ints(x []int) { Sort(IntSlice(x)) }，然后ctrl+鼠标左键点击IntSlice，会跳转到这个代码：

type IntSlice []int

func (x IntSlice) Len() int           { return len(x) }

func (x IntSlice) Less(i, j int) bool { return x[i] < x[j] }

func (x IntSlice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

        调用sort.Ints()时，会调用func Ints(x []int) { Sort(IntSlice(x)) }，也就是把我们的需要排序的元素，传到IntSlice(x)，作用是把元素先转换为自定义IntSlice类型。

       对于Len() int           { return len(x) }来说，就是取出元素长度。

        Swap(i, j int)      { x[i], x[j] = x[j], x[i] }，主要作用就是交换2个元素的位置。

        Less(i, j int) bool { return x[i] < x[j] }，比较元素大小，成立返回true，否则返回flase，并进行位置调整，也就是调用Swap方法，也就是默认升序的情况。

1.1.2 sort.Strings源码解析

sort.Strings()

func Strings(x []string) { Sort(StringSlice(x)) }

type StringSlice []string

func (x StringSlice) Len() int           { return len(x) }

func (x StringSlice) Less(i, j int) bool { return x[i] < x[j] }

func (x StringSlice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

可以看到，int和strings的排序实现逻辑，其实是一样的。

1.2 自定义结构体（切片）排序

package mainimport ("fmt""sort"
)type Runner interface {run()
}type Cat struct {name stringage  int
}type CatSlice []Cat // 这里就相当于[]Cat{c1, c2, Cat{"Momo", 99}}func (x CatSlice) Len() int           { return len(x) }
func (x CatSlice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
func (x CatSlice) Less(i, j int) bool { return x[i].age < x[j].age }func main() {var c1 = Cat{"Tom", 20}var c2 = Cat{"Jerry", 18}cats := []Cat{c1, c2, Cat{"Momo", 99}}fmt.Println("排序前：", cats)sort.Sort(CatSlice(cats))fmt.Println("排序后：", cats)
}
=========调试结果=========
排序前： [{Tom 20} {Jerry 18} {Momo 99}]
排序后： [{Jerry 18} {Tom 20} {Momo 99}]

1.3 简化版结构体（切片）排序

sort.Slice()，是专门给切片用的。

package mainimport ("fmt""sort"
)type Runner interface {run()
}type Cat struct {name stringage  int
}func main() {var c1 = Cat{"Tom", 20}var c2 = Cat{"Jerry", 18}cats := []Cat{c1, c2, Cat{"Momo", 99}}fmt.Println("排序前：", cats)sort.Slice(cats, func(i, j int) bool {return cats[i].age < cats[j].age})fmt.Println("排序后：", cats)
}
=========调试结果=========
排序前： [{Tom 20} {Jerry 18} {Momo 99}]
排序后： [{Jerry 18} {Tom 20} {Momo 99}]

2. map排序

2.1 key排序

2.1.1 升序

package mainimport ("fmt""sort"
)func main() {m := make(map[int]string)m[2] = "abc"m[1] = "xvz"m[100] = "aaa"fmt.Println(m)keys := make([]int, 0, len(m))for k := range m {keys = append(keys, k)}fmt.Println(keys)sort.Ints(keys)fmt.Println(keys)for _, k := range keys {fmt.Println(k, m[k])}
}
=========调试结果=========
map[1:xvz 2:abc 100:aaa]
[2 1 100]
[1 2 100]
1 xvz
2 abc
100 aaa

2.1.2 降序

package mainimport ("fmt""sort"
)func main() {m := make(map[int]string)m[2] = "abc"m[1] = "xvz"m[100] = "aaa"fmt.Println(m)keys := make([]int, 0, len(m))for k := range m {keys = append(keys, k)}fmt.Println(keys)// sort.Ints(keys)sort.Sort(sort.Reverse(sort.IntSlice(keys))) // 调整这里fmt.Println(keys)for _, k := range keys {fmt.Println(k, m[k])}
}
=========调试结果=========
map[1:xvz 2:abc 100:aaa]
[100 2 1]
[100 2 1]
100 aaa
2 abc
1 xvz

2.2 value排序

2.2.1 升序

package mainimport ("fmt""sort"
)type Entry struct {k intv string
}func main() {m := make(map[int]string)m[2] = "abc"m[1] = "xvz"m[100] = "aaa"fmt.Println(m)entries := make([]Entry, 0, len(m))for k, v := range m {entries = append(entries, Entry{k, v})}fmt.Println(entries)sort.Slice(entries, func(i, j int) bool {return entries[i].v < entries[j].v})fmt.Println(entries)
}
=========调试结果=========
map[1:xvz 2:abc 100:aaa]
[{1 xvz} {100 aaa} {2 abc}]
[{100 aaa} {2 abc} {1 xvz}]

3. 排序总结

排序，只支持线性数据结构，如果是hash类型，一定要先转换成线性数据结构。