sort 標(biāo)準(zhǔn)庫

Sort 標(biāo)準(zhǔn)庫提供了對基本數(shù)據(jù)類型的切片和自定義類型的切片進(jìn)行排序的函數(shù)，常用函數(shù)如下表所示：

如果想了解更多函數(shù)的介紹和使用，可以到 pkg.go.dev/sort 進(jìn)行查看。

Ints 和 IntsAreSorted

Ints(x []int)：對 int 類型的切片進(jìn)行排序，將切片作為參數(shù)進(jìn)行傳遞，改變原切片的元素順序

IntsAreSorted(x []int) bool，傳遞一個切片進(jìn)去，判斷此切片是否是升序排序，是則返回 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))
}

執(zhí)行結(jié)果：

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

Float64s 和 Float64sAreSorted

Float64s(x []float64)：對 float64 類型的切片進(jìn)行排序，將切片作為參數(shù)進(jìn)行傳遞，改變原切片的元素順序

Float64sAreSorted(x []float64) bool，傳遞一個切片進(jìn)去，判斷此切片是否是升序排序，是則返回 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))
}

執(zhí)行結(jié)果：

排序前： [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 類型的切片進(jìn)行排序，將切片作為參數(shù)進(jìn)行傳遞，改變原切片的元素順序

StringsAreSorted(x []string) bool，傳遞一個切片進(jìn)去，判斷此切片是否是升序排序，是則返回 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))
}

執(zhí)行結(jié)果：

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

Sort

Sort(data Interface)：對實現(xiàn) Interface 接口的自定義集合類型按照自定義的規(guī)則進(jìn)行排序。

Interface

實現(xiàn) Interface 接口，需要實現(xiàn)以下三個方法：

Len() int 返回集合的長度

Less(i, j) bool

• i 和 j 為兩個元素在集合里的下標(biāo)值
• 該方法返回一個 bool 值， 判斷 i 位置的元素是否應(yīng)該排在 j 之前，如果 bool 值為 false，則說明 i 不應(yīng)該在 j 之前。

Swap(i, j int)

對結(jié)構(gòu)體切片進(jìn)行排序

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)
}

執(zhí)行結(jié)果：

排序前： [{小明 22} {小紅 17} {小花 18}]
排序后： [{小紅 17} {小花 18} {小明 22}]

• 定義 User 結(jié)構(gòu)體，自定義 UserSlice 類型，其基類為 []User User 切片
• 實現(xiàn) sort 包里的 Interface 接口，定義 Len、Less 和 Swap 函數(shù)
• Less 函數(shù)的返回值邏輯為 return us[i].Age < us[j].Age，表示按照年齡字段進(jìn)行升序排序

小結(jié)

本文介紹了如何使用 sort 包里的函數(shù)，對基本數(shù)據(jù)類型的切片進(jìn)行排序。sort 包還提供了對自定義的集合進(jìn)行排序，需要實現(xiàn) Interface 接口，由使用者去自定義排序規(guī)則，通過 sort.Sort 函數(shù)進(jìn)行排序。