go 排序 接口排序

Go sort 包主要提供了三种排序能力：
（1）基本类型切片排序；
（2）任意类型切片排序 ；
（3）任意数据结构排序 (实现接口方法排序)

一、基本类型切片排序

为了便于对常用数据类型的操作，sort 包提供了对 []int切片、[]float64切片 和 []string 切片的排序支持。 切片排序

sort.Ints(sli)
sort.Float64s(sli1)
sort.Strings(sli2)

实现

package main

import (
	"fmt"
	"sort"
)
func main() {
	sli := []int{6, 568, 566, 484, 55}
	sort.Ints(sli)
	fmt.Printf("sli: %v\n", sli)

	sli1 := []float64{6.62, 568.54, 25.566, 484.2, 55.2}
	sort.Float64s(sli1)
	fmt.Printf("sli1: %v\n", sli1)

	sli2 := []string{"aa", "bb", "AA"}
	sort.Strings(sli2)
	fmt.Printf("sli2: %v\n", sli2)
}

二、任意类型的切片排序(如，结构体)

包内代码

func Slice(x any, less func(i, j int) bool) {
	rv := reflectlite.ValueOf(x)
	swap := reflectlite.Swapper(x)
	length := rv.Len()
	limit := bits.Len(uint(length))
	pdqsort_func(lessSwap{less, swap}, 0, length, limit)
}

实现

package main

import (
	"fmt"
	"sort"
)

type student struct {
	name string
	age  int
	hav  int
}

func main() {

	//二、任意类型切片排序(如，结构体)
	a := student{"aa", 32, 120}
	b := student{"bb", 65, 100}
	c := student{"cc", 54, 130}
	d := student{"dd", 814, 62}

	fmt.Println(a, b, c, d)
	ss := []student{
		a, b, c, d,
	}

	sort.Slice(ss, func(i, j int) bool { //切片比较  排序
		return ss[i].age < ss[j].age
	})

	for _, v := range ss { //按行打印
		fmt.Printf("v: %v\n", v)
	}

}

三、任意数据结构排序 (实现接口方法排序)

包内代码

type Interface interface {
	Len() int
	Less(i, j int) bool
	Swap(i, j int)
}
type StringSlice []string
func (x StringSlice) Len() int           { return len(x) }
func (x StringSlice) Less(i, j int) bool { return x[i] < x[j] }
func (x StringSlice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }

func Sort(data Interface) {
	n := data.Len()
	if n <= 1 {
		return
	}
	limit := bits.Len(uint(n))
	pdqsort(data, 0, n, limit)
}
func Stable(data Interface) {
	stable(data, data.Len())
}

实现

package main

import (
	"fmt"
	"sort"
)

type person struct {
	name   string
	age    int
	height int
}
type stringperson []person

//实现sort.Interface 接口方法

func (x stringperson) Len() int { return len(x) }
func (x stringperson) Less(i, j int) bool {
	if x[i].age > x[j].age { //先以年龄作比较
		return true
	}
	return x[i].height > x[j].height //年龄一样的，再比身高

}
func (x stringperson) Swap(i, j int) { x[i], x[j] = x[j], x[i] }

func main() {
	sperson := []person{ //person结构类型的切片
		{"aa", 3, 54},
		{"aa", 2, 54},
		{"aa", 6, 54},
		{"aa", 3, 52},
		{"aa", 12, 15},
	}
	sort.Stable(stringperson(sperson))
	// sort.Sort(stringperson(sperson))
	fmt.Printf("sperson: %v\n", sperson)
}

//返回
//sperson: [{aa 12 15} {aa 6 54} {aa 3 54} {aa 3 52} {aa 2 54}]

-----------end