共计 4127 个字符，预计需要花费 11 分钟才能阅读完成。
Go 语言规范库提供了 sort 包，用于对切片和用户定义的汇合进行排序。
具体示例如下：
根本排序
package main
import (
"fmt"
"sort"
)
func main() {
//float 从小到大排序
f := []float64{5.2, -1.3, 0.7, -3.8, 2.6} // unsorted
sort.Float64s(f)
fmt.Println(f) //[-3.8 -1.3 0.7 2.6 5.2]
//float 倒序
sort.Sort(sort.Reverse(sort.Float64Slice(f)))
fmt.Println(f) //[5.2 2.6 0.7 -1.3 -3.8]
// int 正序 从小到大排序
i := []int{5, 6, 3, 7, 9} // unsorted
sort.Ints(i)
fmt.Println(i) //[3 5 6 7 9]
//int 倒序
sort.Sort(sort.Reverse(sort.IntSlice(i)))
fmt.Println(i) //[9 7 6 5 3]
//string 正序 字母程序
s := []string{"Go", "Bravo", "Gopher", "Alpha", "Grin", "Delta"}
sort.Strings(s)
fmt.Println(s) //[Alpha Bravo Delta Go Gopher Grin]
//int 倒序
sort.Sort(sort.Reverse(sort.StringSlice(s)))
fmt.Println(s) //[Grin Gopher Go Delta Bravo Alpha]
}
在升序切片查找 value
在已排序的切片中搜寻 x，并返回由搜寻指定的索引。如果 x 不存在，返回值是要插入 x 的索引（它能够是 len (a)）。切片必须按升序排序。
package main
import (
"fmt"
"sort"
)
func main() {
// 检索
a := []float64{1.0, 2.0, 3.3, 4.6, 6.1, 7.2, 8.0}
x := 1.0
i := sort.SearchFloat64s(a, x)
fmt.Printf("found %g at index %d in %v\n", x, i, a) //found 2 at index 1 in [1 2 3.3 4.6 6.1 7.2 8] 如果不存在返回 0 a := []int{1, 2, 3, 4, 6, 7, 8}
b := []int{1, 2, 3, 4, 6, 7, 8}
y := 2
j := sort.SearchInts(b, y)
fmt.Printf("found %d at index %d in %v\n", y, j, b) //found 2 at index 1 in [1 2 3 4 6 7 8]
z := 1
i = sort.SearchInts(b, z)
fmt.Printf("%d not found, can be inserted at index %d in %v\n", z, i, b) //1 not found, can be inserted at index 0 in [1 2 3 4 6 7 8]
}留神这种状况，没有检索到和第一个索引的值都是零，所以返回值为 0 时不能作为检索不到某值为根据。
sort.slice
sort.Slice 是 go 1.8 版本中引入的一个弱小排序函数, 有两个参数，第一个参数是带排序 any 类型的切片，第二个参数是 less 函数，用于比拟大小，less 办法必须满足与接口类型的 Less 办法雷同的要求。
此排序不能保障是稳固的：相等的元素可能会从它们的原始程序颠倒过去。对于稳固排序，请应用 SliceStable。
示例：
package main
import (
"fmt"
"sort"
)
func main() {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("By name:", people)
sort.Slice(people, func(i, j int) bool {return people[i].Age < people[j].Age })
fmt.Println("By age:", people)
}
sort.SliceStable
sort.SliceStable 是 go 1.8 版本中引入的一个弱小稳固的排序函数, 应用提供的 less 函数对切片 x 进行排序，放弃相等元素的原始程序。
示例：
package main
import (
"fmt"
"sort"
)
func main() {people := []struct {
Name string
Age int
}{{"Alice", 25},
{"Elizabeth", 75},
{"Alice", 75},
{"Bob", 75},
{"Alice", 75},
{"Bob", 25},
{"Colin", 25},
{"Elizabeth", 25},
}
// Sort by name, preserving original order
sort.SliceStable(people, func(i, j int) bool {return people[i].Name < people[j].Name })
fmt.Println("By name:", people)//By name: [{Alice 25} {Alice 75} {Alice 75} {Bob 75} {Bob 25} {Colin 25} {Elizabeth 75} {Elizabeth 25}]
// Sort by age preserving name order
sort.SliceStable(people, func(i, j int) bool {return people[i].Age < people[j].Age })
fmt.Println("By age,name:", people)//By age,name: [{Alice 25} {Bob 25} {Colin 25} {Elizabeth 25} {Alice 75} {Alice 75} {Bob 75} {Elizabeth 75}]
}Search
在按升序排序的整数切片数据中应用二分法进行查找值 x，返回插入地位
package main
import (
"fmt"
"sort"
)
func main() {a := []int{1, 3, 6, 10, 15, 21, 28, 36, 45, 55}
x := 6
i := sort.Search(len(a), func(i int) bool {return a[i] >= x })
if i < len(a) && a[i] == x {fmt.Printf("found %d at index %d in %v\n", x, i, a)
} else {fmt.Printf("%d not found in %v\n", x, a)
}
}
sort 源码剖析
接口 type Interface
type Interface interface {Len() int // 示意容器蕴含元素的个数。Less(i, j int) bool // 就是比拟函数
Swap(i, j int) // 替换 i 和 j.
}相干类型构造体
type Float64Slice []float64
type IntSlice []int
type StringSlice []string函数
func Ints(a []int)
func IntsAreSorted(a []int) bool // 是否排序
// 在按升序排序的整数切片数据中查找值 x, 留神如查到值第一个，返回的插入地位和查不到值都是 0
func SearchInts(a []int, x int) int // 查找
func Float64s(a []float64)
func Float64sAreSorted(a []float64) bool //
// 在按升序排序的整数切片数据中查找值 x, 留神如查到值第一个，返回的插入地位和查不到值都是 0
func SearchFloat64s(a []float64, x float64) int
func Strings(a []string)
func StringsAreSorted(a []string) bool // 是否排序
// 在按升序排序的整数切片数据中查找值 x, 留神如查到值第一个，返回的插入地位和查不到值都是 0
func SearchStrings(a []string, x string) int
func Sort(data Interface)
func Stable(data Interface)
func Reverse(data Interface) Interface
func ISSorted(data Interface) bool
// 在按升序排序的整数切片数据中查找值 x, 返回的索引地位和查, 第二个参数传入函数
func Search(n int, f func(int) bool) intsort 用到的排序算法
插入排序 (insertionSort_func)、归并排序(symMerge_func)、堆排序（heapSort_func）、疾速排序（pdqsort_func）、归并排序（symMerge_func）
sort 会依据数据从以上四种算法选取一种高效的排序算法。
stable 是稳固排序算法，采纳插入排序(insertionSort_func) 和归并排序 (symMerge_func)。
源码：
func stable_func(data lessSwap, n int) {
blockSize := 20 // must be > 0
a, b := 0, blockSize
for b <= n {insertionSort_func(data, a, b)
a = b
b += blockSize
}
insertionSort_func(data, a, n)
for blockSize < n {
a, b = 0, 2*blockSize
for b <= n {symMerge_func(data, a, a+blockSize, b)
a = b
b += 2 * blockSize
}
if m := a + blockSize; m < n {symMerge_func(data, a, m, n)
}
blockSize *= 2
}
}links
https://pkg.go.dev/[email protected]
正文完
