简介

标准库sort实现了4种排序方法，插入排序、堆排序、快排和归并排序，但是并没有暴露给用户接口。sort包会根据数据选择最优的排序方法(其实只使用了3种，归并排序除外)。

接口

用户需要实现以下接口才能使用sort包的排序功能。

type Interface interface {    // Len is the number of elements in the collection.    Len() int    // Less reports whether the element with    // index i should sort before the element with index j.    Less(i, j int) bool    // Swap swaps the elements with indexes i and j.    Swap(i, j int)}

type reverse struct {    Interface}func (r reverse) Less(i, j int) bool {    return r.Interface.Less(j, i)}func Reverse(data Interface) Interface {    return &reverse{data}}func IsSorted(data Interface) bool { // 当前排序与Less()方法排序一致返回True    n := data.Len()    for i := n - 1; i > 0; i-- {        if data.Less(i, i-1) {            return false        }    }    return true}

内置类型支持

对于常用的类型(整型切片、float64切片、String切片)，sort包提供了内置的接口实现

type IntSlice []intfunc (p IntSlice) Len() int           { return len(p) }func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }func (p IntSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }func (p IntSlice) Sort() { Sort(p) }type Float64Slice []float64func (p Float64Slice) Len() int           { return len(p) }func (p Float64Slice) Less(i, j int) bool { return p[i] < p[j] || isNaN(p[i]) && !isNaN(p[j]) }func (p Float64Slice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }func isNaN(f float64) bool {    return f != f}func (p Float64Slice) Sort() { Sort(p) }type StringSlice []stringfunc (p StringSlice) Len() int           { return len(p) }func (p StringSlice) Less(i, j int) bool { return p[i] < p[j] }func (p StringSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }func (p StringSlice) Sort() { Sort(p) }

使用举例如下：

package mainimport (    "fmt"    "sort")func main() {    instance := sort.IntSlice{1, 5, 8, 9, 7, 1}    sort.Sort(instance)    fmt.Println(instance) // [1 1 5 7 8 9]    sort.Sort(sort.Reverse(instance))    fmt.Println(instance) // [9 8 7 5 1 1]}

自定义类型排序

package mainimport (    "fmt"    "sort")type Person struct {    age  int    name string    sex  string}type PersonSlice []Personfunc (p PersonSlice) Len() int {    return len(p)}func (p PersonSlice) Less(i, j int) bool {    return p[i].age < p[j].age}func (p PersonSlice) Swap(i, j int) {    p[i], p[j] = p[j], p[i]}func (p PersonSlice) Sort() {    sort.Sort(p)}func main() {    instance := PersonSlice{{12, "Jack", "male"}, {15, "Lucy", "famale"}, {13, "Lilei", "male"}}    instance.Sort()    fmt.Println(instance) // [{12 Jack male} {13 Lilei male} {15 Lucy famale}]}

其它封装函数

// Ints sorts a slice of ints in increasing order.func Ints(a []int) { Sort(IntSlice(a)) }// Float64s sorts a slice of float64s in increasing order// (not-a-number values are treated as less than other values).func Float64s(a []float64) { Sort(Float64Slice(a)) }// Strings sorts a slice of strings in increasing order.func Strings(a []string) { Sort(StringSlice(a)) }// IntsAreSorted tests whether a slice of ints is sorted in increasing order.func IntsAreSorted(a []int) bool { return IsSorted(IntSlice(a)) }// Float64sAreSorted tests whether a slice of float64s is sorted in increasing order// (not-a-number values are treated as less than other values).func Float64sAreSorted(a []float64) bool { return IsSorted(Float64Slice(a)) }// StringsAreSorted tests whether a slice of strings is sorted in increasing order.func StringsAreSorted(a []string) bool { return IsSorted(StringSlice(a)) }

举例如下：

package mainimport (    "fmt"    "sort")func main() {    num := []int{1, 5, 8, 9, 7, 1}    fmt.Println(sort.IntsAreSorted(num)) // false    sort.Ints(num)    fmt.Println(num, sort.IntsAreSorted(num)) // [1 1 5 7 8 9] true}

给这篇文章的作者打赏

微信扫一扫打赏

支付宝扫一扫打赏

×

打赏 点赞(0)