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

1.sort.sort介绍

使用sort.slice进行排序，因为slice把struct抽象化了，且slice封装过了，简单的基础类型可以使用sort,使用sort排序需要重写三个interface,不想学习sort排序的可以直接看第三步

这里将对比sort跟slice两种排序的使用方式

1.1分析内置sort包

1.2分析sort.go

要想实现自定义对象的排序功能，需要重写这三个interface

外部调用sort方法即可实现排序

 

func sort(data interface) {
n := data.len()
quicksort(data, 0, n, maxdepth(n))
}

通过sort源码可以看到用的快速排序，不懂快排的可以自行重温快排算法，这里就不讲解快排原理了

2.使用方法

2.1基础类型排序

基础类型的排序直接在sort.go去找就行了

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)

}

2.2对象排序（单一字段）

如果对一个struct对象的某一个字段进行排序就需要重写一组len,less,swap接口，如果有多组就需要重写多组接口。

下面直接看例子：

如果一个对象只有一个字段需要排序就用下面的例子比较简单

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)

}

2.3对象排序（多字段）

多个了sortby方法可以确定是升序还是降序，同时可以确定排序字段是哪个

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)
}

如果不喜欢用sortby方法，也可以重写多个less、len、swap方法，

下面的方法就调用起来比较简单，不用重写by跟sortby方法，但是上面的比较灵活（理解可能比下面的费劲）

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)
}
}

3.sort.slice介绍

3.1使用方法

很明显将对象抽象成interface,而上面对对象的排序，只能是person这种特定对象

调用的时候有点类似java的重写compare方法

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)
}
}

3.2运行

到此这篇关于golag 使用sort.slice包实现对象list排序的文章就介绍到这了,更多相关golag 对象list排序内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！