Go自定义排序

C++中实现自定义排序，可以在sort函数的最后一个参数位上，加上一个自定义的比大小函数或者仿函数来实现：

lambda表达式

// v是vector<int>类型
sort(v.begin(), v.end(), [](int a, int b) {
    
     return a > b;
});

仿函数

class SortInt {
    
public:
     bool operator() (int a, int b) {
    
         return a > b;
     }
};
sort(v.begin(), v.end(), SortInt());

Go语言中通过sort包提供的接口和函数，也可以实现自定义排序.

三种基本类型升序排序

如果要排序的切片是int64, float64, string类型，且是升序排序，可以使用下面三个函数进行排序：

sort.Ints(x []int)
sort.Float64s(x []float64)
sort.Strings(x []string)

sort.Sort(data Interface)

这个函数可以对自定义类型的切片进行排序，前提是这种自定义类型得实现Interface接口.

Interface

type Interface interface {
    
	Len() int
	Less(i, j int) bool
	Swap(i, j int)
}

int类型举例

type sortInt []int

func (arr sortInt) Len() int {
    
	return len(arr)
}
func (arr sortInt) Less(i, j int) bool {
    
	return arr[i] < arr[j]
}

func (arr sortInt) Swap(i, j int) {
    
	arr[i], arr[j] = arr[j], arr[i]
}

func main() {
    
	arr := []int{
    1, 4, 6, 3, 10}
	var _arr sortInt = arr
	sort.Sort(_arr)
	sort.Sort(sort.Reverse(_arr))  // 逆序排序
}

struct类型举例

type Students []Student

func (s Students) Len() int {
    
	return len(s)
}
func (s Students) Less(i, j int) bool {
    
	return s[i].score < s[j].score
}
func (s Students) Swap(i, j int) {
    
	s[i], s[j] = s[j], s[i]
}

func main() {
    
	var students Students
	students = []Student{
    
		Student{
    "zhangsan", 89},
		Student{
    "lisi", 98},
		Student{
    "wangwu", 78},
	}
	sort.Sort(students)
}

sort.Slice(x interface{}, less func(i, j int) bool)

这个函数可以对切片类型进行排序，还需要提供一个返回值为bool类型的函数对象.

int类型举例

arr := []int{
    1, 4, 6, 3, 10}
sort.Slice(arr, func(i, j int) bool {
    
	return arr[i] > arr[j]
})

struct类型举例

students := []Student{
    
		Student{
    "zhangsan", 89},
		Student{
    "lisi", 98},
		Student{
    "wangwu", 78},
}
sort.Slice(students, func(i, j int) bool {
    
	return students[i].score > students[j].score
})
fmt.Println(students)

这样看来使用sort.Slice好像更加方便一些，之后发现更加高级的功能再追加.