Overview

Package sort provides primitives for sorting slices and user-defined collections. 

sort包提供对各切片[float64, int, string]和用户定义的数据类型的排序

Function

• 内置类型

  注意各函数的命名, 此处跟在类型后面的s代表的是复数[切片], 还有用的是Are

  • 排序

    默认增序

    • func Float64s(x []float64)

    • func Ints(x []int)

    • func Strings(x []string)

  • 检验是否排序

    • func Float64sAreSorted(x []float64) bool

    • func IntsAreSorted(x []int) bool

    • func StringsAreSorted(x []string) bool

  • 查找

    返回x的第一个位置, 如果x不存在, 那就返回x应该插入的位置. 注意, 切片应该是已经增序排列的

    • func SearchFloat64s(a []float64, x float64) int

    • func SearchInts(a []int, x int) int

    • func SearchStrings(a []string, x string) int

• 自定义类型

  • 排序 

    • func Sort(data Interface)

    • func Stable(data Interface)

    • func Slice(x interface{}, less func(i, j int) bool) // 如果x不是slice, panic

    • func SliceStable(x interface{}, less func(i, j int) bool)

  • 检验是否排序

    • func IsSorted(data Interface) bool

    • func SliceIsSorted(x interface{}, less func(i, j int) bool) // 如果x不是slice, panic

  • 查找

    返回第一个满足 f(i) == true 的集合元素对应的下标i, 如果没找到, 返回n. 注意, 本函数使用的是二分查找, 要求前一半不满足, 后一半满足(均可以为空), 等于需要另外判断

    • func Search(n int, f func(int) bool) int

      x := 23
      i := sort.Search(len(data), func(i int) bool { return data[i] >= x })
      if i < len(data) && data[i] == x {
      	// x is present at data[i]
      } else {
      	// x is not present in data,
      	// but i is the index where it would be inserted.
      }

Types

• Interface

  type Interface interface {
      // 集合中数据的个数
  	Len() int
  
      // 稳定性通过sort包下的方法来处理, 注意NaN
      // 当true时, i排在j前面
  	Less(i, j int) bool
  
  	// go中的交换非常简单
  	Swap(i, j int)
  }

• Float64Slice

  • type Float64Slice []float64

  • func (x Float64Slice) Len() int

  • func (x Float64Slice) Less(i, j int) bool

  • func (p Float64Slice) Search(x float64) int

  • func (x Float64Slice) Sort()

  • func (x Float64Slice) Swap(i, j int)

• IntSlice

  • type IntSlice []int

  • func (x IntSlice) Len() int

  • func (x IntSlice) Less(i, j int) bool

  • func (p IntSlice) Search(x int) int

  • func (x IntSlice) Sort()

  • func (x IntSlice) Swap(i, j int)

• StringSlice

  • type StringSlice []string

  • func (x StringSlice) Len() int

  • func (x StringSlice) Less(i, j int) bool

  • func (p StringSlice) Search(x string) int

  • func (x StringSlice) Sort()

  • func (x StringSlice) Swap(i, j int)

Example

package main

import (
	"fmt"
	"sort"
)

type Person struct {
	Name string
	Age  int
}

func (p Person) String() string {
	return fmt.Sprintf("%s: %d", p.Name, p.Age)
}

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 }

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

	fmt.Println(people)
	sort.Sort(ByAge(people))
	fmt.Println(people)

	sort.Slice(people, func(i, j int) bool {
		return people[i].Age > people[j].Age
	})
	fmt.Println(people)
}