Go+自定义排序教程（4.2）

import (
  "fmt"
  "sort"
)

// Student 学生struct
type Student struct {
  Name         string
  Age          int
  EnglishScore int
  MathScore    int
}

// OrderByAge Student数组的别名，用于实现sort.Interface接口
// OrderByAge 可以直接使用sort.Sort来排序
type OrderByAge []Student
func (a OrderByAge) Len() int           { return len(a) }
func (a OrderByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a OrderByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }

students := []Student{
  { Name: "Lilei", Age: 18, EnglishScore: 78, MathScore: 79 },
  { Name: "Hanmeimei", Age: 17, EnglishScore: 79, MathScore: 99 },
  { Name: "Hetingting", Age: 19, EnglishScore: 71, MathScore: 68 },
}

println "students:", students

// 对students进行Age字段排序
sort.Sort(OrderByAge(students))
println "by age  :", students

import (
  "fmt"
  "sort"
)

type Student struct {
  Name         string
  Age          int
  EnglishScore int
  MathScore    int
}

// OrderBy 定义排序函数别名
// 用于定义StudentSorter排序器的排序规则
type OrderBy func(s1, s2 *Student) bool
func (by OrderBy) Sort(students []Student) {
  ss := &StudentSorter{
    Students: students,
    OrderBy:  by, // 它的Sort函数定义的排序的具体规则，它是可变的，所以可以有不同排序规则传递
  }
  sort.Sort(ss)
}

// StudentSorter student的排序器，实现了sort.Interface接口
// 包括student集合数据和排序的规则定义
type StudentSorter struct {
  Students []Student
  OrderBy  OrderBy
}
func (s StudentSorter) Len() int           { return len(s.Students) }
func (s StudentSorter) Swap(i, j int)      { s.Students[i], s.Students[j] = s.Students[j], s.Students[i] }
func (s StudentSorter) Less(i, j int) bool { return s.OrderBy(&s.Students[i], &s.Students[j]) }

students := []Student{
  { Name: "Lilei", Age: 18, EnglishScore: 78, MathScore: 79 },
  { Name: "Hanmeimei", Age: 17, EnglishScore: 79, MathScore: 66 },
  { Name: "Hetingting", Age: 19, EnglishScore: 71, MathScore: 68 },
}

println "students:", students

// 定义按照EnglishScore排序的规则
englishScore := func(s1, s2 *Student) bool {
  return s1.EnglishScore < s2.EnglishScore
}
OrderBy(englishScore).Sort(students)
println "By EnglishScore  :", students

// 定义按照MathScore排序的规则
mathScore := func(s1, s2 *Student) bool {
  return s1.MathScore < s2.MathScore
}
OrderBy(mathScore).Sort(students)
println "By MathScore  :", students

import (
    "fmt"
    "sort"
)

type Student struct {
    Name         string
    Age          int
    EnglishScore int
    MathScore    int
}

// OrderBy 定义排序函数别名
// 用于定义StudentSorter排序器的排序规则
type OrderBy func(s1, s2 *Student) bool

// MultiSorter student的排序器，实现了sort.Interface接口
// 包括student集合数据和排序的规则定义，其中排序规则是多个带有优先级的排序
type MultiSorter struct {
    Students []Student
    OrderBys []OrderBy
}

func (s *MultiSorter) Sort(students []Student) {
    s.Students = students
    sort.Sort(s)
}

func (s *MultiSorter) Len() int { return len(s.Students) }

func (s *MultiSorter) Swap(i, j int) { s.Students[i], s.Students[j] = s.Students[j], s.Students[i] }

func (s *MultiSorter) Less(i, j int) bool {
    p, q := &s.Students[i], &s.Students[j]
    for index, orderBy := range s.OrderBys {
        // 因为这里需要考虑相等情况下，进行下一轮比较，所以不能直接返回比较结果
        switch {
        case orderBy(p, q):
            // 明确不需要调换位置
            return true
        case orderBy(q, p):
            // 明确需要调换位置，也要返回
            return false
        }
        if index == len(s.Students)-2 {
            return orderBy(p, q) // 之前都没出结果，不论如何最后一个返回结果就行了
        }
    }
    return true
}

// OrderedBy multiSorter的排序器构造函数
// 使用多个排序规则初始化，返回一个排序器
func OrderedBy(orderBys ...OrderBy) *MultiSorter {
    return &MultiSorter{
        OrderBys: orderBys,
    }
}

students := []Student{
    {Name: "Lilei", Age: 18, EnglishScore: 78, MathScore: 79},
    {Name: "Hanmeimei", Age: 17, EnglishScore: 78, MathScore: 66},
    {Name: "Hetingting", Age: 19, EnglishScore: 71, MathScore: 68},
}

fmt.Println("students:", students)

// 定义按照EnglishScore排序的规则
englishScore := func(s1, s2 *Student) bool {
    return s1.EnglishScore < s2.EnglishScore
}

// 定义按照MathScore排序的规则
mathScore := func(s1, s2 *Student) bool {
    return s1.MathScore < s2.MathScore
}

OrderedBy(englishScore).Sort(students)
fmt.Println("By EnglishScore:", students)

OrderedBy(englishScore, mathScore).Sort(students)
fmt.Println("By EnglishScore and MathScore: ", students)

import (
  "fmt"
  "sort"
)

// Student 学生struct
type Student struct {
  Name         string
  Age          int
  EnglishScore int
  MathScore    int
}

// OrderByAge Student数组的别名，用于实现sort.Interface接口
// OrderByAge 可以直接使用sort.Sort来排序
type OrderByAge []Student
func (a OrderByAge) Len() int           { return len(a) }
func (a OrderByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a OrderByAge) Less(i, j int) bool {
  // 请注意，和第一个例子，只有这里不同
  // 奇数在前，偶数在后
  if (a[i].Age + a[j].Age) % 2 == 0 {
    // 说明要么都是奇数，要么都是偶数，返回true
    return true
  }
  
  if a[i].Age % 2 == 0 {
    // 说明i是偶数，j是奇数，需要调换位置
    return false
  }
  // 否则就是不用调换
  return true
}

students := []Student{
  { Name: "Lilei", Age: 18, EnglishScore: 78, MathScore: 79 },
  { Name: "Hanmeimei", Age: 17, EnglishScore: 79, MathScore: 99 },
  { Name: "Hetingting", Age: 19, EnglishScore: 71, MathScore: 68 },
}

println "students:", students

// 对students进行Age字段排序
sort.Sort(OrderByAge(students))
println "by age  :", students