一文掌握使用 Go 标准库 sort 对切片进行排序

时间：2022-12-21 11:24:27

耐心和持久胜过激烈和*。

哈喽大家好，我是陈明勇，今天分享的内容是使用 Go 标准库 sort 对切片进行排序。如果本文对你有帮助，不妨点个赞，如果你是 Go 语言初学者，不妨点个关注，一起成长一起进步，如果本文有错误的地方，欢迎指出！

sort 标准库

Sort 标准库提供了对基本数据类型的切片和自定义类型的切片进行排序的函数，常用函数如下表所示：

函数

描述

Ints(x []int)

对 int 类型的切片进行升序排序

IntsAreSorted(x []int) bool

判断 int 类型的切片是否是升序排序

Float64s(x []float64)

对 float64 类型的切片进行升序排序

Float64sAreSorted(x []float64) bool

判断 float64 类型的切片是否是升序排序

Strings(x []string)

对 string 类型的切片进行升序排序

StringsAreSorted(x []string) bool

判断 string 类型的切片是否是升序排序

Sort(data Interface)

对自定义类型的切片进行排序，自定义类型必须实现 Interface 接口

如果想了解更多函数的介绍和使用，可以到 ​​https://pkg.go.dev/sort​​ 进行查看。

Ints 和 IntsAreSorted

​​Ints(x []int)​​：对 ​​int​​ 类型的切片进行排序，将切片作为参数进行传递，改变原切片的元素顺序

​​IntsAreSorted(x []int) bool​​，传递一个切片进去，判断此切片是否是升序排序，是则返回 ​​true​​，否则返回 ​​false​​。

import (
  "fmt"
  "sort"
)

func main() {
  nums := []int{5, 3, 1, 2, 4, 7}
  fmt.Println("排序前：", nums)
  fmt.Println("切片是否是升序排序：", sort.IntsAreSorted(nums))
  sort.Ints(nums)
  fmt.Println("排序后：", nums)
  fmt.Println("切片是否是升序排序：", sort.IntsAreSorted(nums))
}

执行结果：

排序前： [5 3 1 2 4 7]
切片是否是升序排序： false
排序后： [1 2 3 4 5 7]
切片是否是升序排序： true

Float64s 和 Float64sAreSorted

​​Float64s(x []float64)​​：对 ​​float64​​ 类型的切片进行排序，将切片作为参数进行传递，改变原切片的元素顺序

​​Float64sAreSorted(x []float64) bool​​，传递一个切片进去，判断此切片是否是升序排序，是则返回 ​​true​​，否则返回 ​​false​​。

import (
  "fmt"
  "sort"
)

func main() {
  nums := []float64{0.0, 1.5, 1.0, 2.4, 4.4, 7.3}
  fmt.Println("排序前：", nums)
  fmt.Println("切片是否是升序排序：", sort.Float64sAreSorted(nums))
  sort.Float64s(nums)
  fmt.Println("排序后：", nums)
  fmt.Println("切片是否是升序排序：", sort.Float64sAreSorted(nums))
}

执行结果：

排序前： [0 1.5 1 2.4 4.4 7.3]
切片是否是升序排序： false
排序后： [0 1 1.5 2.4 4.4 7.3]
切片是否是升序排序： true

Strings 和 StringsAreSorted

​​Strings(x []string)​​：对 ​​float64​​ 类型的切片进行排序，将切片作为参数进行传递，改变原切片的元素顺序

​​StringsAreSorted(x []string) bool​​，传递一个切片进去，判断此切片是否是升序排序，是则返回 ​​true​​，否则返回 ​​false​​。

import (
  "fmt"
  "sort"
)

func main() {
  strs := []string{"d", "a", "c", "b"}
  fmt.Println("排序前：", strs)
  fmt.Println("切片是否是升序排序：", sort.StringsAreSorted(strs))
  sort.Strings(strs)
  fmt.Println("排序后：", strs)
  fmt.Println("切片是否是升序排序：", sort.StringsAreSorted(strs))
}

执行结果：

排序前： [d a c b]
切片是否是升序排序： false
排序后： [a b c d]
切片是否是升序排序： true

Sort

​​Sort(data Interface)​​：对实现 ​​Interface​​ 接口的自定义集合类型按照自定义的规则进行排序。

Interface

实现 ​​Interface​​ 接口，需要实现以下三个方法：

  • ​​Len() int​​ 返回集合的长度
  • ​Less(i, j) bool​
  • ​​i​​ 和 ​​j​​ 为两个元素在集合里的下标值
  • 该方法返回一个 ​​bool​​ 值， 判断 ​​i​​ 位置的元素是否应该排在 ​​j​​ 之前，如果 ​​bool​​ 值为 ​​false​​，则说明 ​​i​​ 不应该在 ​​j​​ 之前。
  • ​​Swap(i, j int)​​

对结构体切片进行排序

import (
  "fmt"
  "sort"
)

type User struct {
  Name string
  Age  int
}

type UserSlice []User

func (us UserSlice) Len() int {
  return len(us)
}

func (us UserSlice) Less(i, j int) bool {
  return us[i].Age < us[j].Age
}

func (us UserSlice) Swap(i, j int) {
  us[i], us[j] = us[j], us[i]
}

func main() {
  us := UserSlice{
    User{Name: "小明", Age: 22},
    User{Name: "小红", Age: 17},
    User{Name: "小花", Age: 18},
  }
  fmt.Println("排序前：", us)
  sort.Sort(us)
  fmt.Println("排序后：", us)
}

执行结果：

排序前： [{小明 22} {小红 17} {小花 18}]
排序后： [{小红 17} {小花 18} {小明 22}]
  • 定义 ​​User​​ 结构体，自定义 ​​UserSlice​​ 类型，其基类为 ​​[]User​​ ​​User​​ 切片
  • 实现 ​​sort​​ 包里的 ​​Interface​​ 接口，定义 ​​Len​​、​​Less​​ 和 ​​Swap​​ 函数
  • ​​Less​​ 函数的返回值逻辑为 ​​return us[i].Age < us[j].Age​​，表示按照年龄字段进行升序排序

小结

本文介绍了如何使用 ​​sort​​ 包里的函数，对基本数据类型的切片进行排序。​​sort​​ 包还提供了对自定义的集合进行排序，需要实现 ​​Interface​​ 接口，由使用者去自定义排序规则，通过 ​​sort.Sort​​ 函数进行排序。

标签：

相关文章