Go语言基础：sort包的使用基础-一一网

基础使用

整数排序

排序：

s := []int{5, 2, 6, 3, 1, 4} // 乱序
sort.Ints(s)
fmt.Println(s)
// 输出: [1 2 3 4 5 6]
复制代码

判断是否有序：

s := []int{1, 2, 3, 4, 5, 6} // 升序
fmt.Println(sort.IntsAreSorted(s))

s = []int{6, 5, 4, 3, 2, 1} // 降序
fmt.Println(sort.IntsAreSorted(s))

s = []int{3, 2, 4, 1, 5} // 乱序
fmt.Println(sort.IntsAreSorted(s))

// 输出:
// true
// false
// false
复制代码

浮点数排序

排序：

s := []float64{5.2, -1.3, 0.7, -3.8, 2.6} // 乱序
sort.Float64s(s)
fmt.Println(s)

s = []float64{math.Inf(1), math.NaN(), math.Inf(-1), 0.0} // 乱序
sort.Float64s(s)
fmt.Println(s)

// 输出:
// [-3.8 -1.3 0.7 2.6 5.2]
// [NaN -Inf 0 +Inf]
复制代码

判断是否有序：

s := []float64{0.7, 1.3, 2.6, 3.8, 5.2} // 升序
fmt.Println(sort.Float64sAreSorted(s))

s = []float64{5.2, 3.8, 2.6, 1.3, 0.7} // 降序
fmt.Println(sort.Float64sAreSorted(s))

s = []float64{5.2, 1.3, 0.7, 3.8, 2.6} // 乱序
fmt.Println(sort.Float64sAreSorted(s))

// 输出:
// true
// false
// false
复制代码

逆序

s := []int{5, 2, 6, 3, 1, 4} // unsorted
sort.Sort(sort.Reverse(sort.IntSlice(s)))
fmt.Println(s)
// 输出: [6 5 4 3 2 1]
复制代码

切片

不稳定排序：

people := []struct {
       Name string
       Age  int
}{
       {"Gopher", 7},
       {"Alice", 55},
       {"Vera", 24},
       {"Bob", 75},
}
sort.Slice(people, func(i, j int) bool { return people[i].Name < people[j].Name })
fmt.Println("按名称排序 :", people)

sort.Slice(people, func(i, j int) bool { return people[i].Age < people[j].Age })
fmt.Println("按年龄排序 :", people)
// 输出:
// 按名称排序 : [{Alice 55} {Bob 75} {Gopher 7} {Vera 24}]
// 按年龄排序 : [{Gopher 7} {Vera 24} {Alice 55} {Bob 75}]
复制代码

稳定排序：

people := []struct {
            Name string
            Age  int
        }{
            {"Alice", 25},
            {"Elizabeth", 75},
            {"Alice", 75},
            {"Bob", 75},
            {"Alice", 75},
            {"Bob", 25},
            {"Colin", 25},
            {"Elizabeth", 25},
        }

// 按名称排序，保持原有顺序
sort.SliceStable(people, func(i, j int) bool { return people[i].Name < people[j].Name })
fmt.Println("按名称排序:", people)

// 按年龄排序，保持原有名称顺序
sort.SliceStable(people, func(i, j int) bool { return people[i].Age < people[j].Age })
fmt.Println("按年龄名称排序:", people)

// 输出:
// 按名称排序 : [{Alice 25} {Alice 75} {Alice 75} {Bob 75} {Bob 25} {Colin 25} {Elizabeth 75} {Elizabeth 25}]
// 按年龄名称排序 : [{Alice 25} {Bob 25} {Colin 25} {Elizabeth 25} {Alice 75} {Alice 75} {Bob 75} {Elizabeth 75}]
复制代码

字符串

func ExampleStrings() {
            s := []string{"Go", "Bravo", "Gopher", "Alpha", "Grin", "Delta"}
            sort.Strings(s)
            fmt.Println(s)
            // 输出: [Alpha Bravo Delta Go Gopher Grin]
}
复制代码

自定义类型

结构体

type Person struct {
	Name string
	Age  int
}
复制代码

接口实现

如果要使用sort包中的函数对自定义结构体进行排序的话，该结构体需要实现sort.Interface接口，也就是Len()、Less()和Swap()这三个函数。

// ByAge 根据 年龄字段 为 []Person 实现 sort.Interface
type ByAge []Person

func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
复制代码

使用

people := []Person{
            {"Bob", 31},
            {"John", 42},
            {"Michael", 17},
            {"Jenny", 26},
        }

fmt.Println(people)
// 有两种对切片排序的方法。
// 第一种是像ByAge一样为切片类型定义一系列方法
// 然后调用sort.Sort()方法。
sort.Sort(ByAge(people))
fmt.Println(people)

// 另一种方法是向sort.Slice()方法传入一个Less()函数
sort.Slice(people, func(i, j int) bool {
        return people[i].Age > people[j].Age
})
fmt.Println(people)

// 输出:
// [Bob: 31 John: 42 Michael: 17 Jenny: 26]
// [Michael: 17 Jenny: 26 Bob: 31 John: 42]
// [John: 42 Bob: 31 Jenny: 26 Michael: 17]
复制代码