sort包包含了切片排序和用户自定义数据集的相关函数，主要功能如下
- 计算长度
- 比较两个下标对应值的大小
- 排序
- 根据不同key值排序
- 多key值组合排序
- 排序的包装模式
- IsSorted 检查对象是否已经被排过序
- Reverse 反向排列
计算整数切片的长度
func (p IntSlice) Len() int
import (
"sort"
"fmt"
)
func main() {
list := sort.IntSlice{1,2,3,4,5,6}
fmt.Println(list.Len())
}
image.png
比较两个索引对应值的大小
func (p IntSlice) Less(i, j int) bool
i对应的值是否小于j对应的值
package main
import (
"sort"
"fmt"
)
func main() {
list := sort.IntSlice{1,2,3,4,5,6}
fmt.Println(list.Less(1,2))
}
image.png
排序
数组要实现排序，需要实现下面的接口
type Interface interface {
// Len is the number of elements in the collection.
Len() int
// Less reports whether the element with
// index i should sort before the element with index j.
Less(i, j int) bool
// Swap swaps the elements with indexes i and j.
Swap(i, j int)
}
下面看一下示例
package main
import (
"fmt"
"sort"
)
type Person struct {
Name string
Age int
}
func (p Person) String() string {
return fmt.Sprintf("%s: %d", p.Name, p.Age)
}
// ByAge 给[]Person 实现了 sort.Interface 接口
// 数组使用排序算法需要实现下面三个方法
type ByAge []Person
func (a ByAge) Len() int { return len(a) }
func (a ByAge) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
func Example() {
people := []Person{
{"a", 1},
{"b", 3},
{"c", 4},
{"d", 2},
}
fmt.Println(people)
//进行排序
sort.Sort(ByAge(people))
fmt.Println(people)
}
func main() {
Example()
}
image.png
以上我们就完成了对person 数组按照age从小到大的排序
根据不同key值排序
如果我们想要实现多种排序方式,比如上面的例子,我们有时需要按照年龄排序,有时需要按照姓名排序该如何实现呢?
方法1 让数组动态绑定排序方法Less(i, j int) bool
package main
import (
"fmt"
"sort"
)
type Person struct {
Name string
Age int
}
func (p Person) String() string {
return fmt.Sprintf("%s: %d", p.Name, p.Age)
}
// ByAge 给[]Person 实现了 sort.Interface 接口
// 数组使用排序算法需要实现下面三个方法
type personsSort struct {
Persons []Person
by func (Person,Person)bool
}
func (a personsSort) Len() int { return len(a.Persons) }
func (a personsSort) Swap(i, j int) { a.Persons[i], a.Persons[j] = a.Persons[j], a.Persons[i] }
func (a personsSort) Less(i, j int) bool { return a.by(a.Persons[i],a.Persons[j]) }
// 定义一个动态排序方法
type By func(Person,Person)bool
func (by By)Sort(perons []Person){
personsSort := &personsSort{
Persons:perons,
by:by,
}
sort.Sort(personsSort)
}
func Example() {
peoples := []Person{
{"b", 1},
{"a", 3},
{"c", 4},
{"d", 2},
}
// 按照名字排序
name := func (p1,p2 Person)bool{
return p1.Name < p2.Name
}
// 按照
age := func(p1,p2 Person) bool{
return p1.Age < p2.Age
}
By(name).Sort(peoples)
fmt.Println(peoples)
By(age).Sort(peoples)
fmt.Println(peoples)
}
func main() {
Example()
}
image.png
多key值组合排序
有的时候,我们需要对用户的姓名先排序,然后在按照姓名去排序，再用其他字段去排序,那么对于这样的需求我们该如何实现呢?
package main
import (
"fmt"
"sort"
)
func main() {
Example_sortMultiKeys()
}
// 第一步创建一个对象结构体
type User struct {
name string
age int
address string
}
// 定义筛选类型
type lessFunc func(p1, p2 *User) bool
// 第二步 构造一个能够执行多个key值筛选的结构体
type multiSorter struct {
user []User
less []lessFunc
}
// 第三步 创建多筛选对象
func OrderedBy(less ...lessFunc) *multiSorter {
return &multiSorter{
less: less,
}
}
// 第四步 实现sort.interface 接口
func (ms *multiSorter) Len() int {
return len(ms.user)
}
func (ms *multiSorter) Swap(i, j int) {
ms.user[i], ms.user[j] = ms.user[j], ms.user[i]
}
func (ms *multiSorter) Less(i, j int) bool {
p, q := &ms.user[i], &ms.user[j]
var k int
// 按照删选算法的顺序进行比较，如果两个值相等,则使用下一个筛选算法进行比较，如果算法只有一个，则不执行for 直接执行这个算法
for k = 0; k < len(ms.less)-1; k++ {
less := ms.less[k]
switch {
case less(p, q):
return true
case less(q, p):
return false
}
}
return ms.less[k](p, q)
}
// 第五步 实现排序算法
func (ms *multiSorter) Sort(changes []User) {
ms.user = changes
sort.Sort(ms)
}
var changes = []User{
{name:"a",age:12,address:"yunnan"},
{name:"a",age:13,address:"yunnan"},
{name:"a",age:13,address:"fujian"},
{name:"d",age:15,address:"shangxi"},
}
func Example_sortMultiKeys() {
name := func(c1, c2 *User) bool {
return c1.name < c2.name
}
age := func(c1, c2 *User) bool {
return c1.age < c2.age
}
address := func(c1, c2 *User) bool {
return c1.address < c2.address
}
OrderedBy(name).Sort(changes)
fmt.Println("By name:", changes)
OrderedBy(name,age).Sort(changes)
fmt.Println("By name,age", changes)
OrderedBy(name, age, address).Sort(changes)
fmt.Println("By name,age,address", changes)
}
image.png
排序的包装模式
在对于按照多种选择的排序的形式比如有时需要按照名称 有时需要按照年龄,这样的排序需求,我们也可以通过包装模式进行设计
package main
import (
"sort"
"fmt"
)
func main() {
Example_sortMultiKeys()
}
// 第一步创建一个对象结构体
type User struct {
name string
age int
address string
}
type Users []User
func (users Users)Len() int{
return len(users)
}
func (users Users)Swap(i,j int){
users[i],users[j] = users[j],users[i]
}
// 包装按照姓名排序
type ByName struct {
Users
}
func (byName ByName)Less(i,j int)bool{
return byName.Users[i].name < byName.Users[j].name
}
// 包装按照年龄排序
type ByAge struct {
Users
}
func (byAge ByAge)Less(i,j int)bool{
return byAge.Users[i].age < byAge.Users[j].age
}
var changes = []User{
{name:"a",age:12,address:"yunnan"},
{name:"d",age:15,address:"shangxi"},
{name:"a",age:14,address:"yunnan"},
{name:"a",age:13,address:"fujian"},
}
func Example_sortMultiKeys() {
sort.Sort(ByName{changes})
fmt.Println("by name:",changes)
sort.Sort(ByAge{changes})
fmt.Println("by age:",changes)
}
image.png
检查数组是否已经执行排序
func IsSorted(data Interface) bool
func Example_sortMultiKeys() {
fmt.Println(sort.IsSorted(ByName{changes}))
sort.Sort(ByName{changes})
fmt.Println("by name:",changes)
fmt.Println(sort.IsSorted(ByName{changes}))
}
反向排序
func Reverse(data Interface) Interface
Reverse包装一个Interface接口并返回一个新的Interface接口，对该接口排序可生成递减序列
func Example_sortMultiKeys() {
sort.Sort(ByName{changes})
fmt.Println("by name:",changes)
sort.Sort(sort.Reverse(ByName{changes}))
fmt.Println("by name:",changes)
}
网友评论