Golang学习聽-聽sort聽包
--------------------
// 满足 Interface 接口的类型可以被本包的函数进行排序。
type Interface interface {
聽聽聽聽// Len 方法返回集合中的元素个数
聽聽聽聽Len() int
聽聽聽聽// Less 方法报告索引 i 的元素是否比索引 j 的元素小
聽聽聽聽Less(i, j int) bool
聽聽聽聽// Swap 方法交换索引 i 和 j 的两个元素的位置
聽聽聽聽Swap(i, j int)
}
// 对 data 进行排序（不保证相等元素的相对顺序不变）
// data 默认为升序，执行 Reverse 后为降序。
func聽Sort(data Interface)
// 对 data 进行排序（保证相等元素的相对顺序不变）
// data 默认为升序，执行 Reverse 后为降序。
func聽Stable(data Interface)
// 将 data 的排序动作更改为降序，Reverse 并不改变元素顺序，只改变排序行为。
// 更改操作不可逆，更改后的对象不可以再次 Reverse。
func聽Reverse(data Interface) Interface
// 判断 data 是否已经排序
// 未执行 Reverse 的必须为升序，执行 Reverse 的必须为降序
func聽IsSorted(data Interface) bool
--------------------
// 示例
func聽main() {
聽聽聽聽i := []int{3, 7, 1, 3, 6, 9, 4, 1, 8, 5, 2, 0}聽
聽聽聽聽a := sort.IntSlice(i)聽
聽聽聽聽fmt.Println(sort.IsSorted(a)) // false聽
聽聽聽聽sort.Sort(a)
聽聽聽聽fmt.Println(a) 聽聽// [0 1 1 2 3 3 4 5 6 7 8 9]聽聽聽聽
聽聽聽聽fmt.Println(sort.IsSorted(a), "\n") // true b := sort.IntSlice{3}聽
聽聽聽聽fmt.Println(sort.IsSorted(b), "\n") // true
聽聽聽聽// 更改排序行为聽
聽聽聽聽c := sort.Reverse(a)
聽聽聽聽fmt.Println(sort.IsSorted(c)) // false聽
聽聽聽聽fmt.Println(c) 聽 聽 聽 聽 聽 聽 聽 聽// &{[0 1 1 2 3 3 4 5 6 7 8 9]
聽聽聽聽sort.Sort(c) fmt.Println(c) 聽聽// &{[9 8 7 6 5 4 3 3 2 1 1 0]}
聽聽聽聽fmt.Println(sort.IsSorted(c), "\n") // true
聽聽聽聽// 再次更改排序行为聽
聽聽聽聽d := sort.Reverse(c)聽
聽聽聽聽fmt.Println(sort.IsSorted(d)) // false聽
聽聽聽聽sort.Sort(d)聽
聽聽聽聽fmt.Println(d) 聽 聽 聽 聽 聽 聽 聽 聽// &{0xc42000a3b0}
聽聽聽聽fmt.Println(sort.IsSorted(d)) // true
聽聽聽聽fmt.Println(d) 聽 聽 聽 聽 聽 聽 聽 聽// &{0xc42000a3b0}
}
--------------------
// 对 a 进行升序排列
func聽Ints(a []int)
// 判断 a 是否为升序排列
func聽IntsAreSorted(a []int) bool
// 搜索 a 中值为 x 的索引，如果找不到，则返回最接近且大于 x 的值的索引，
// 可能是 len(a)。
func聽SearchInts(a []int, x int) int
--------------------
// 示例
func聽main() {聽
聽聽聽聽a := []int{3, 9, 1, 6, 4, 2, 8, 2, 4, 5, 3, 0}聽
聽聽聽聽sort.Ints(a)聽
聽聽聽聽fmt.Println(a) // [0 1 2 2 3 3 4 4 5 6 8 9]
聽聽聽聽fmt.Println(sort.IntsAreSorted(a)) // true聽
聽聽聽聽i := sort.SearchInts(a, 7)聽
聽聽聽聽fmt.Println(a[i]) // 8
}
--------------------
// 功能同上，类型不同
func聽Float64s(a []float64)
func聽Float64sAreSorted(a []float64) bool
func聽SearchFloat64s(a []float64, x float64) int聽// 功能同上，类型不同
func聽Strings(a []string)
func聽StringsAreSorted(a []string) bool
func聽SearchStrings(a []string, x string) int
--------------------
// 实现了 sort.Interface 接口的 []int 类型
type IntSlice []int聽
func (p IntSlice) Len() int
// 接口方法
func (p IntSlice) Less(i, j int) bool
// 接口方法
func (p IntSlice) Swap(i, j int)
// 接口方法
// 对 p 进行升序排列
func (p IntSlice) Sort()
// 搜索 p 中值为 x 的索引，如果找不到，则返回最接近且大于 x 的值的索引，
// 可能是 len(a)。
func (p IntSlice) Search(x int) int
--------------------
// 示例
func聽main() {
聽聽聽聽a := sort.IntSlice{3, 7, 1, 3, 6, 9, 4, 1, 8, 5, 2, 0}
聽聽聽聽a.Sort()聽
聽聽聽聽fmt.Println(a)聽 聽 聽 聽 聽 聽 聽 聽 // [0 1 1 2 3 3 4 5 6 7 8 9]
聽聽聽聽fmt.Println(sort.IsSorted(a)) // true聽
聽聽聽聽i := a.Search(6)聽
聽聽聽聽fmt.Println(i, a[i])聽 聽 聽 聽 聽 // 8 6
}
--------------------
// 功能同上，类型不同
type Float64Slice []float64
func (p Float64Slice) Len() int
func (p Float64Slice) Less(i, j int) bool
func (p Float64Slice) Swap(i, j int)
func (p Float64Slice) Sort()
func (p Float64Slice) Search(x float64) int
// 功能同上，类型不同
type StringSlice []string
func (p StringSlice) Len() int
func (p StringSlice) Less(i, j int) bool
func (p StringSlice) Swap(i, j int)
func (p StringSlice) Sort()
func (p StringSlice) Search(x string) int
--------------------
// Search 采用二分法搜索，在小于 n 的索引中查找最小的满足 f(索引) 的值。返
// 回找到的索引，如果没有符合要求的索引，则返回 n。
func聽Search(n int, f func(int) bool) int
--------------------
// 示例
func聽main() {
聽聽聽聽a := sort.StringSlice{"hello", "world", "golang", "sort", "nice"}聽
聽聽聽聽a.Sort() // 二分法必须先排序
聽聽聽聽// 获取首字母大于 n 的元素中最小的聽
聽聽聽聽i := sort.Search(len(a), func(i int) bool {
聽聽聽聽聽聽聽聽return聽len(a[i]) > 0 && a[i][0] > 'n'聽
聽聽聽聽})
聽聽聽聽// 显示找到的元素聽
聽聽聽聽fmt.Println(a[i]) // sort
}
有疑问加站长微信联系（非本文作者）
