golang 使用sort.slice包实现对象list排序

func Sort(data Interface) {
n := data.Len()
quickSort(data, 0, n, maxDepth(n))
}

package main

import (
"fmt"
"sort"
)

func main() {
intList := [] int {2, 4, 3, 5, 7, 6, 9, 8, 1, 0}
float8List := [] float64 {4.2, 5.9, 12.3, 10.0, 50.4, 99.9, 31.4, 27.81828, 3.14}
stringList := [] string {"a", "c", "b", "d", "f", "i", "z", "x", "w", "y"}

sort.Ints(intList)
sort.Float64s(float8List)
sort.Strings(stringList)

fmt.Printf("%v\n%v\n%v\n", intList, float8List, stringList)

}

package main

import (
"fmt"
"sort"
)

type Person struct {
Name string
Age int
}

// 按照 Person.Age 从大到小排序
type PersonSlice [] Person

func (a PersonSlice) Len() int { // 重写 Len() 方法
return len(a)
}
func (a PersonSlice) Swap(i, j int){ // 重写 Swap() 方法
a[i], a[j] = a[j], a[i]
}
func (a PersonSlice) Less(i, j int) bool { // 重写 Less() 方法， 从大到小排序
return a[j].Age < a[i].Age
}

func main() {
people := [] Person{
{"zhang san", 12},
{"li si", 30},
{"wang wu", 52},
{"zhao liu", 26},
}

fmt.Println(people)

sort.Sort(PersonSlice(people)) // 按照 Age 的逆序排序
fmt.Println(people)

sort.Sort(sort.Reverse(PersonSlice(people))) // 按照 Age 的升序排序
fmt.Println(people)

}

package main

import (
"fmt"
"sort"
)

type Person struct {
Name string
Age int
}

type PersonWrapper struct {
people [] Person
by func(p, q * Person) bool
}
//用来判断升序还是降序
type SortBy func(p, q *Person) bool

func (pw PersonWrapper) Len() int { // 重写 Len() 方法
return len(pw.people)
}
func (pw PersonWrapper) Swap(i, j int){ // 重写 Swap() 方法
pw.people[i], pw.people[j] = pw.people[j], pw.people[i]
}
func (pw PersonWrapper) Less(i, j int) bool { // 重写 Less() 方法
return pw.by(&pw.people[i], &pw.people[j])
}

// 封装成 SortPerson 方法
func SortPerson(people [] Person, by SortBy){
sort.Sort(PersonWrapper{people, by})
}

func main() {
people := [] Person{
{"zhang san", 12},
{"li si", 30},
{"wang wu", 52},
{"zhao liu", 26},
}

fmt.Println(people)

//推荐用封装的SortPerson方法
sort.Sort(PersonWrapper{people, func (p, q *Person) bool {
return q.Age < p.Age // Age 递减排序
}})

fmt.Println(people)

//推荐用这种
SortPerson(people, func (p, q *Person) bool {
return p.Name < q.Name // Name 递增排序
})

fmt.Println(people)
}

package main

import (
"fmt"
"sort"
)

type Person struct {
Name string
Weight int
}

type PersonSlice []Person

func (s PersonSlice) Len() int { return len(s) }
func (s PersonSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }

type ByName struct{ PersonSlice } // 将 PersonSlice 包装起来到 ByName 中

func (s ByName) Less(i, j int) bool { return s.PersonSlice[i].Name < s.PersonSlice[j].Name } // 将 Less 绑定到 ByName 上


type ByWeight struct{ PersonSlice } // 将 PersonSlice 包装起来到 ByWeight 中
func (s ByWeight) Less(i, j int) bool { return s.PersonSlice[i].Weight < s.PersonSlice[j].Weight } // 将 Less 绑定到 ByWeight 上

func main() {
s := []Person{
{"apple", 12},
{"pear", 20},
{"banana", 50},
{"orange", 87},
{"hello", 34},
{"world", 43},
}

sort.Sort(ByWeight{s})
fmt.Println("People by weight:")
printPeople(s)

sort.Sort(ByName{s})
fmt.Println("\nPeople by name:")
printPeople(s)

}

func printPeople(s []Person) {
for _, o := range s {
fmt.Printf("%-8s (%v)\n", o.Name, o.Weight)
}
}

package main

import (
"fmt"
"sort"
)

type Person struct {
Name string
Weight int
}


func main() {
s := []Person{
{"apple", 12},
{"pear", 20},
{"banana", 50},
{"orange", 87},
{"hello", 34},
{"world", 43},
}

//可以向上面一样对排序字段封装，加一个sortby字段传递
sort.Slice(s,func(i,j int)bool{
return s[i].Weight < s[j].Weight
})
fmt.Println("People by weight:")
printPeople(s)

sort.Slice(s,func(i,j int)bool{
return s[i].Name < s[j].Name
})
fmt.Println("\nPeople by name:")
printPeople(s)

}

func printPeople(s []Person) {
for _, o := range s {
fmt.Printf("%-8s (%v)\n", o.Name, o.Weight)
}
}