Go切片排序

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]

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

在升序切片查找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]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

注意这种情况，没有检索到和第一个索引的值都是零，所以返回值为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)

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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}]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

sort源码分析

接口 type Interface

type Interface interface {
    Len() int  //表示容器包含元素的个数。
    Less(i, j int) bool //就是比较函数
    Swap(i, j int) //交换i 和 j.
}
1
2
3
4
5

相关类型结构体

type Float64Slice []float64
type IntSlice []int
type StringSlice []string
1
2
3

函数

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) int
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

sort用到的排序算法
插入排序(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
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

links

https://pkg.go.dev/sort@go1.19.2