前言
在任何編程語言中，關乎到數據的排序都會有對應的策略，我們來看下 Golang 是怎樣對數據進行排序，以及我們如何優化處理使用
go 排序
go 可以針對任何對象排序，雖然很多情況下是一個 slice 切片，或者是包含 slice 的一個對象。
go 排序（接口）有三個要素：
- 待排序元素個數 n ；
- 第 i 和第 j 個元素的比較函數 cmp ；
- 第 i 和 第 j 個元素的交換 swap ；
基本類型 int 、 float64 和 string 的排序
升序排序
對於 int、float64、string 數組或切片的排序，Golang 分別提供了 sort.Ints()、sort.Float64s()、sort.Strings()函數，默認都是從小到大排序。
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)
}
輸出
[0 1 2 3 4 5 6 7 8 9]
[3.14 4.2 5.9 10 12.3 27.81828 31.4 50.4 99.9]
[a b c d f i w x y z]
降序排序
對於 int、float64、string 都有默認的升序排序函數，現在問題是怎樣才能降序呢？
在 go 中的 sort 包有一個 sort.Interface 接口，該接口有三個方法 Len()、Less()、Swap(i, j)。通用排序函數 sort.Sort 可以排序任何實現了 sort.Interface 接口的對象（變量）。對於 []int、[]float64、[]string 除了使用特殊指定的函數外，還可以使用改裝過的類型 IntSclice、Float64Slice 和 StringSlice，然后直接調用它們對應的 Sort() 方法，因為這三種類型也實現了 sortInterface接口，所以可以通過 sort.Reverse 來轉換這三種類型的 Interface.Less 方法來實現逆向排序。
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.Sort(sort.Reverse(sort.IntSlice(intList)))
sort.Sort(sort.Reverse(sort.Float64Slice(float8List)))
sort.Sort(sort.Reverse(sort.StringSlice(stringList)))
fmt.Printf("%v\n%v\n%v\n", intList, float8List, stringList)
}
輸出
[9 8 7 6 5 4 3 2 1 0]
[99.9 50.4 31.4 27.81828 12.3 10 5.9 4.2 3.14]
[z y x w i f d c b a]
下面使用一個自定義的 Reverse 結構體，而不是 sort.Reverse 函數，來實現逆向排序。
package main
import (
"fmt"
"sort"
)
// 自定義的 Reverse 類型
type Reverse struct {
sort.Interface // 這樣， Reverse 可以接納任何實現了 sort.Interface (包括 Len, Less, Swap 三個方法) 的對象
}
// Reverse 只是將其中的 Inferface.Less 的順序對調了一下
func (r Reverse) Less(i, j int) bool {
return r.Interface.Less(j, i)
}
func main() {
doubles := []float64{3.5, 4.2, 8.9, 100.98, 20.14, 79.32}
fmt.Printf("doubles is asc ? %v\n", sort.Float64sAreSorted(doubles))
//sort.Float64s(doubles) // float64 正序排序 方法1
//sort.Sort(sort.Float64Slice(doubles)) // float64 正序排序 方法2
(sort.Float64Slice(doubles)).Sort() // float64 排序方法 方法3
fmt.Println("after sort by Sort:\t", doubles)
sort.Sort(Reverse{sort.Float64Slice(doubles)}) // float64 逆序排序
fmt.Println("after sort by Reversed Sort:\t", doubles)
}
輸出
doubles is asc ? false
after sort by Sort: [3.5 4.2 8.9 20.14 79.32 100.98]
after sort by Reversed Sort: [100.98 79.32 20.14 8.9 4.2 3.5]
以上只是說明了基礎類型怎樣進行排序。
結構體類型排序
在實際應用中，結構體排序我們會用得更多。結構體類型排序是通過使用 sort.Sort(slice) 實現的，只要 slice 實現了 sort.Interface 的三個方法就可以完成排序。但針對不同排序的要求，排序的方式有好幾種。
第一種
第一種模擬排序 []int 構造對應的 IntSlice 類型，然后對 IntSlice 類型實現 Interface 的三個方法。
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)
}
輸出
[{zhang san 12} {li si 30} {wang wu 52} {zhao liu 26}]
[{wang wu 52} {li si 30} {zhao liu 26} {zhang san 12}]
[{zhang san 12} {zhao liu 26} {li si 30} {wang wu 52}]
第二種
第一種排序的缺點是：根據 Age 排序需要重新定義 PersonSlice 方法，綁定 Len、Less 和 Swap 方法，如果需要根據 Name 排序，又需要重新寫三個函數。如果結構體有 4 個字段，就會有 4 種排序，那么就要寫 3 * 4 = 12 個方法，，即使有一些完全是多余的（O__O"…），仔細想一下，根據不同的標准 Age 或是 Name，真正的不同體現在 Less 方法上，所以我們可以將 Less 抽象出來，每種排序的 Less 讓其變成動態的。
package main
import (
"fmt"
"sort"
)
type Person struct {
Name string // 姓名
Age int // 年紀
}
type PersonWrapper struct {
people []Person
by 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])
}
func main() {
people := []Person{
{"zhang san", 12},
{"li si", 30},
{"wang wu", 52},
{"zhao liu", 26},
}
fmt.Println(people)
sort.Sort(PersonWrapper{people, func(p, q *Person) bool {
return q.Age < p.Age // Age 遞減排序
}})
fmt.Println(people)
sort.Sort(PersonWrapper{people, func(p, q *Person) bool {
return p.Name < q.Name // Name 遞增排序
}})
fmt.Println(people)
}
輸出
[{zhang san 12} {li si 30} {wang wu 52} {zhao liu 26}]
[{wang wu 52} {li si 30} {zhao liu 26} {zhang san 12}]
[{li si 30} {wang wu 52} {zhang san 12} {zhao liu 26}]
將 []Person 和比較的准則 cmp 封裝到一起，形成了 PersonWrapper 結構體，然后在其上綁定 Len、Less 和 Swap 方法。實際上 sort.Sort(pw) 排序的是 pw 中的 people，也就是 go 排序的對象可以是數組或者切片。
第三種
第二種排序方法已經很不錯啦，唯一一個缺點是，在 main 中使用的時候暴露了 sort.Sort 的使用，還有就是 PersonWrapper 的構造。為了讓 main 中使用起來更為方便，我們可以再簡單的封裝一下，構造一個 SortPerson 方法。
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])
}
func SortPerson(people []Person, by SortBy) { // SortPerson 方法
sort.Sort(PersonWrapper{people, by})
}
func main() {
people := []Person{
{"zhang san", 12},
{"li si", 30},
{"wang wu", 52},
{"zhao liu", 26},
}
fmt.Println(people)
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)
}
輸出
[{zhang san 12} {li si 30} {wang wu 52} {zhao liu 26}]
[{wang wu 52} {li si 30} {zhao liu 26} {zhang san 12}]
[{li si 30} {wang wu 52} {zhang san 12} {zhao liu 26}]
在方法二的基礎上構建了 SortPerson 函數，使用的時候只需要傳入一個 []Person 和一個 cmp 函數。
第四種
其實是另外一種實現思路，可以說是方法一、方法二的變體。
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)
}
}
輸出
People by weight:
apple (12)
pear (20)
hello (34)
world (43)
banana (50)
orange (87)
People by name:
apple (12)
banana (50)
hello (34)
orange (87)
pear (20)
world (43)
對結構體的排序，暫時就到這里。第一種排序適用於只根據一個字段排序比較合適，另外三種排序方法可根據多個字段排序。第四種方法每次都要多構造一個 ByXXX，很不方便，不如方法二和方法三，方法三只是簡單封裝了下方法二，對使用者來說，會更加方便一些，而且也會更少的出錯。