Polar Snow Documentation

花有重开日 人无再少年

go语言sort排序基本用法

发表于 分类于 Disqus：

go语言中预置了[]int []float64 []String三种数据类型的排序函数, 如果需要对其他数据类型进行排序, 需要自己实现sort interface

内置数据类型排序

[]int 类型排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func main() {
	fmt.Println("------------ Int Slice ------------")
	
	// 待排序的数据
	is := []int{19, 26, 3, 78, 56}
	fmt.Println("排序前的Int Slice", is)
	fmt.Println("Int Slice是否已经按升序排序", sort.IntsAreSorted(is))
	
	// 使用内置的排序函数进行排序
	sort.Ints(is)
	
	// 排序后
	fmt.Println("排序后的Int Slice", is)
	fmt.Println("Int Slice是否已经按升序排序", sort.IntsAreSorted(is))
	sort.Sort(sort.Reverse(sort.IntSlice(is)))
	fmt.Println("逆序排列(降序)后的Int Slice", is)
}

运行结果:

1
2
3
4
5
6
------------ Int Slice ------------
排序前的Int Slice [19 26 3 78 56]
Int Slice是否已经按升序排序 false
排序后的Int Slice [3 19 26 56 78]
Int Slice是否已经按升序排序 true
逆序排列(降序)后的Int Slice [78 56 26 19 3]

[]float64 类型排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func main() {
	fmt.Println("------------ Float64 Slice ------------")
	
	// 待排序数据
	f64s := []float64{98.5, 53.2, 78.5, 12.78}
	fmt.Println("排序前的Float64 Slice", f64s)
	fmt.Println("Float64 Slice是否已经按升序排序", sort.Float64sAreSorted(f64s))
	
	// 使用内置的排序函数进行排序
	sort.Float64s(f64s)
	
	// 排序后
	fmt.Println("排序后的Float64 Slice", f64s)
	fmt.Println("Float64 Slice是否已经按升序排序", sort.Float64sAreSorted(f64s))
	sort.Sort(sort.Reverse(sort.Float64Slice(f64s)))
	fmt.Println("逆序排列(降序)后的Float64 Slice", f64s)
}

运行结果:

1
2
3
4
5
6
------------ Float64 Slice ------------
排序前的Float64 Slice [98.5 53.2 78.5 12.78]
Float64 Slice是否已经按升序排序 false
排序后的Float64 Slice [12.78 53.2 78.5 98.5]
Float64 Slice是否已经按升序排序 true
逆序排列(降序)后的Float64 Slice [98.5 78.5 53.2 12.78]

[]string 类型排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func main() {
	fmt.Println("------------ String Slice ------------")
	
	// 待排序数据
	ss := []string{"watermelon", "apple", "strawberry", "orange"}
	fmt.Println("排序前的String Slice", ss)
	fmt.Println("String Slice是否已经按升序排序", sort.StringsAreSorted(ss))
	
	// 使用内置的排序函数进行排序
	sort.Strings(ss)
	
	// 排序后
	fmt.Println("排序后的String Slice", ss)
	fmt.Println("String Slice是否已经按升序排序", sort.StringsAreSorted(ss))
	sort.Sort(sort.Reverse(sort.StringSlice(ss)))
	fmt.Println("逆序排列(降序)后的String Slice", ss)
}

运行结果:

1
2
3
4
5
6
------------ String Slice ------------
排序前的String Slice [watermelon apple strawberry orange]
String Slice是否已经按升序排序 false
排序后的String Slice [apple orange strawberry watermelon]
String Slice是否已经按升序排序 true
逆序排列(降序)后的String Slice [watermelon strawberry orange apple]

其他数据类型排序

int8 int16 int32 int64 float32 虽然也是常用的数据类型, 但是这些数据类型需要自己实现排序接口

1
2
3
4
5
6
7
8
9
10
11
12
// A type, typically a collection, that satisfies sort.Interface can be
// sorted by the routines in this package. The methods require that the
// elements of the collection be enumerated by an integer index.
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)
}

[]int32 类型排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
type Int32Slice []int32

func (s Int32Slice) Len() int {
	return len(s)
}

func (s Int32Slice) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]
}

func (s Int32Slice) Less(i, j int) bool {
	return s[i] < s[j]
}

func main() {
    i32s := Int32Slice{19, 26, 3, 78, 56}
	sort.Sort(i32s)
	fmt.Println(i32s)
}

运行结果:

1
[3 19 26 56 78]

[]float32 类型排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
type Float32Slice []float32

func (s Float32Slice) Len() int {
	return len(s)
}

func (s Float32Slice) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]
}

func (s Float32Slice) Less(i, j int) bool {
	return s[i] < s[j]
}

func main() {
    f32s := Float32Slice{98.5, 53.2, 78.5, 12.78}
	sort.Sort(f32s)
	fmt.Println(f32s)
}

运行结果:

1
[12.78 53.2 78.5 98.5]
相关文章