2. 程式人生 > >go語言的排序、結構體排序

go語言的排序、結構體排序

阿新 • • 發佈：2017-11-08
sea 封裝 class 讓其 其他 zhang import 過去 blue

原文：https://studygolang.com/articles/1598

晚上準備動手寫點 go 的程序的時候，想起 go 如何排序的問題。排序 sort 是個基本的操作，當然搜索 search 也是。c 提供一個 qsort 和 bsearch，一個快排一個二分查找，不過是使用起來都不方便； c++ 中的 sort 貌似很不錯，因為 c++ 支持泛型(或是說模板)，所以很多東西使用起來很方便。go 是通過 sort 包提供排序和搜索，因為 go 暫時不支持泛型（將來也不好說支不支持），所以，go 的 sort 和 search 使用起來跟類型是有關的，或是需要像 c 一樣寫比較函數等，稍微顯得也不是很方便。

補註： 近來又看 go 的排序， 發現以前對 go 的排序理解的有點淺了。 go 的排序思路和 c 和 c++ 有些差別。 c 默認是對數組進行排序， c++ 是對一個序列進行排序， go 則更寬泛一些，待排序的可以是任何對象， 雖然很多情況下是一個 slice (分片， 類似於數組)，或是包含 slice 的一個對象。

排序(接口)的三個要素：

  1. 待排序元素個數 n ；
  2. 第 i 和第 j 個元素的比較函數 cmp ；
  3. 第 i 和 第 j 個元素的交換 swap ；

乍一看條件 3 是多余的， c 和 c++ 都不提供 swap 。 c 的 qsort 的用法： qsort(data, n, sizeof(int), cmp_int); data 是起始地址， n 是元素個數， sizeof(int) 是每個元素的大小， cmp_int 是一個比較兩個 int 的函數。c++ 的 sort 的用法： sort(data, data+n, cmp_int); data 是第一個元素的位置， data+n 是最後一個元素的下一個位置， cmp_int 是比較函數。

下面還是進入正題。

基本類型 int 、 float64 和 string 的排序

升序排序

對於 int 、 float64 和 string 數組或是分片的排序， go 分別提供了 sort.Ints() 、 sort.Float64s() 和 sort.Strings() 函數， 默認都是從小到大排序。(沒有 sort.Float32s() 函數， me 頗有點奇怪。)

  1. package main
  3. import (
  4. "fmt"
  5. "sort"
  6. )
  8. func main() {
  9. intList := [] int {2, 4, 3, 5, 7, 6, 9, 8, 1, 0}
  10. float8List := [] float64 {4.2, 5.9, 12.3, 10.0, 50.4, 99.9, 31.4, 27.81828, 3.14}
  11. // float4List := [] float32 {4.2, 5.9, 12.3, 10.0, 50.4, 99.9, 31.4, 27.81828, 3.14} // no function : sort.Float32s
  12. stringList := [] string {"a", "c", "b", "d", "f", "i", "z", "x", "w", "y"}
  14. sort.Ints(intList)
  15. sort.Float64s(float8List)
  16. sort.Strings(stringList)
  18. fmt.Printf("%v\n%v\n%v\n", intList, float8List, stringList)
  20. }

降序排序

int 、 float64 和 string 都有默認的升序排序函數， 現在問題是如果降序如何 ？ 有其他語言編程經驗的人都知道，只需要交換 cmp 的比較法則就可以了， go 的實現是類似的，然而又有所不同。 go 中對某個 Type 的對象 obj 排序， 可以使用 sort.Sort(obj) 即可，就是需要對 Type 類型綁定三個方法 ： Len() 求長度、 Less(i,j) 比較第 i 和 第 j 個元素大小的函數、 Swap(i,j) 交換第 i 和第 j 個元素的函數。sort 包下的三個類型 IntSlice 、 Float64Slice 、 StringSlice 分別實現了這三個方法， 對應排序的是 [] int 、 [] float64 和 [] string 。如果期望逆序排序， 只需要將對應的 Less 函數簡單修改一下即可。

go 的 sort 包可以使用 sort.Reverse(slice) 來調換 slice.Interface.Less ，也就是比較函數，所以， int 、 float64 和 string 的逆序排序函數可以這麽寫：

  1. package main
  3. import (
  4. "fmt"
  5. "sort"
  6. )
  8. func main() {
  9. intList := [] int {2, 4, 3, 5, 7, 6, 9, 8, 1, 0}
  10. float8List := [] float64 {4.2, 5.9, 12.3, 10.0, 50.4, 99.9, 31.4, 27.81828, 3.14}
  11. stringList := [] string {"a", "c", "b", "d", "f", "i", "z", "x", "w", "y"}
  13. sort.Sort(sort.Reverse(sort.IntSlice(intList)))
  14. sort.Sort(sort.Reverse(sort.Float64Slice(float8List)))
  15. sort.Sort(sort.Reverse(sort.StringSlice(stringList)))
  17. fmt.Printf("%v\n%v\n%v\n", intList, float8List, stringList)
  18. }

深入理解排序

sort 包中有一個 sort.Interface 接口，該接口有三個方法 Len() 、 Less(i,j) 和 Swap(i,j) 。 通用排序函數 sort.Sort 可以排序任何實現了 sort.Inferface 接口的對象(變量)。對於 [] int 、[] float64 和 [] string 除了使用特殊指定的函數外，還可以使用改裝過的類型 IntSclice 、 Float64Slice 和 StringSlice ， 然後直接調用它們對應的 Sort() 方法；因為這三種類型也實現了 sort.Interface 接口， 所以可以通過 sort.Reverse 來轉換這三種類型的 Interface.Less 方法來實現逆向排序， 這就是前面最後一個排序的使用。

下面使用了一個自定義(用戶定義)的 Reverse 結構體， 而不是 sort.Reverse 函數， 來實現逆向排序。

  1. package main
  3. import (
  4. "fmt"
  5. "sort"
  6. )
  8. // 自定義的 Reverse 類型
  9. type Reverse struct {
  10. sort.Interface // 這樣， Reverse 可以接納任何實現了 sort.Interface (包括 Len, Less, Swap 三個方法) 的對象
  11. }
  13. // Reverse 只是將其中的 Inferface.Less 的順序對調了一下
  14. func (r Reverse) Less(i, j int) bool {
  15. return r.Interface.Less(j, i)
  16. }
  18. func main() {
  19. ints := []int{5, 2, 6, 3, 1, 4} // 未排序
  21. sort.Ints(ints) // 特殊排序函數， 升序
  22. fmt.Println("after sort by Ints:\t", ints) // [1 2 3 4 5 6]
  24. doubles := []float64{2.3, 3.2, 6.7, 10.9, 5.4, 1.8}
  26. sort.Float64s(doubles) // float64 排序版本 1
  27. fmt.Println("after sort by Float64s:\t", doubles) // [1.8 2.3 3.2 5.4 6.7 10.9]
  29. strings := []string{"hello", "good", "students", "morning", "people", "world"}
  30. sort.Strings(strings)
  31. fmt.Println("after sort by Strings:\t", strings) // [good hello mornig people students world]
  33. ipos := sort.SearchInts(ints, -1) // int 搜索
  34. fmt.Printf("pos of 5 is %d th\n", ipos) // 並不總是正確呀 ! (搜索不是重點)
  36. dpos := sort.SearchFloat64s(doubles, 20.1) // float64 搜索
  37. fmt.Printf("pos of 5.0 is %d th\n", dpos) // 並不總是正確呀 !
  39. fmt.Printf("doubles is asc ? %v\n", sort.Float64sAreSorted(doubles))
  41. doubles = []float64{3.5, 4.2, 8.9, 100.98, 20.14, 79.32}
  42. // sort.Sort(sort.Float64Slice(doubles)) // float64 排序方法 2
  43. // fmt.Println("after sort by Sort:\t", doubles) // [3.5 4.2 8.9 20.14 79.32 100.98]
  44. (sort.Float64Slice(doubles)).Sort() // float64 排序方法 3
  45. fmt.Println("after sort by Sort:\t", doubles) // [3.5 4.2 8.9 20.14 79.32 100.98]
  47. sort.Sort(Reverse{sort.Float64Slice(doubles)}) // float64 逆序排序
  48. fmt.Println("after sort by Reversed Sort:\t", doubles) // [100.98 79.32 20.14 8.9 4.2 3.5]
  49. }

sort.Ints / sort.Float64s / sort.Strings 分別來對整型/浮點型/字符串型分片或是叫做片段，或是不嚴格滴說是數組，進行排序。然後是有個測試是否有序的函數。還有分別對應的 search 函數，不過，發現搜索函數只能定位到如果存在的話的位置，不存在的話，位置就是不對的。

關於一般的數組排序，程序中顯示了，有 3 種方法！目前提供的三種類型 int，float64 和 string 呈現對稱的，也就是你有的，對應的我也有。

關於翻轉排序或是逆向排序，就是用個翻轉結構體，重寫 Less 函數即可。上面的 Reverse 是個通用的結構體。

上面說了那麽多， 只是對基本類型進行排序， 該到說說 struct 結構體類型的排序的時候了， 實際中這個用得到的會更多。

結構體類型的排序

結構體類型的排序是通過使用 sort.Sort(slice) 實現的， 只要 slice 實現了 sort.Interface 的三個方法就可以。 雖然這麽說，但是排序的方法卻有那麽好幾種。首先一種就是模擬排序 [] int 構造對應的 IntSlice 類型，然後對 IntSlice 類型實現 Interface 的三個方法。

結構體排序方法 1

  1. package main
  3. import (
  4. "fmt"
  5. "sort"
  6. )
  8. type Person struct {
  9. Name string // 姓名
  10. Age int // 年紀
  11. }
  13. // 按照 Person.Age 從大到小排序
  14. type PersonSlice [] Person
  16. func (a PersonSlice) Len() int { // 重寫 Len() 方法
  17. return len(a)
  18. }
  19. func (a PersonSlice) Swap(i, j int){ // 重寫 Swap() 方法
  20. a[i], a[j] = a[j], a[i]
  21. }
  22. func (a PersonSlice) Less(i, j int) bool { // 重寫 Less() 方法， 從大到小排序
  23. return a[j].Age < a[i].Age
  24. }
  26. func main() {
  27. people := [] Person{
  28. {"zhang san", 12},
  29. {"li si", 30},
  30. {"wang wu", 52},
  31. {"zhao liu", 26},
  32. }
  34. fmt.Println(people)
  36. sort.Sort(PersonSlice(people)) // 按照 Age 的逆序排序
  37. fmt.Println(people)
  39. sort.Sort(sort.Reverse(PersonSlice(people))) // 按照 Age 的升序排序
  40. fmt.Println(people)
  42. }

這完全是一種模擬的方式，所以如果懂了 IntSlice 自然就理解這裏了，反過來，理解了這裏那麽 IntSlice 那裏也就懂了。

結構體排序方法 2

方法 1 的缺點是 ： 根據 Age 排序需要重新定義 PersonSlice 方法，綁定 Len 、 Less 和 Swap 方法， 如果需要根據 Name 排序， 又需要重新寫三個函數； 如果結構體有 4 個字段，有四種類型的排序，那麽就要寫 3 × 4 = 12 個方法， 即使有一些完全是多余的， O__O"… 仔細思量一下，根據不同的標準 Age 或是 Name， 真正不同的體現在 Less 方法上，所以， me 們將 Less 抽象出來， 每種排序的 Less 讓其變成動態的，比如下面一種方法。

  1. package main
  3. import (
  4. "fmt"
  5. "sort"
  6. )
  8. type Person struct {
  9. Name string // 姓名
  10. Age int // 年紀
  11. }
  13. type PersonWrapper struct {
  14. people [] Person
  15. by func(p, q * Person) bool
  16. }
  18. func (pw PersonWrapper) Len() int { // 重寫 Len() 方法
  19. return len(pw.people)
  20. }
  21. func (pw PersonWrapper) Swap(i, j int){ // 重寫 Swap() 方法
  22. pw.people[i], pw.people[j] = pw.people[j], pw.people[i]
  23. }
  24. func (pw PersonWrapper) Less(i, j int) bool { // 重寫 Less() 方法
  25. return pw.by(&pw.people[i], &pw.people[j])
  26. }
  28. func main() {
  29. people := [] Person{
  30. {"zhang san", 12},
  31. {"li si", 30},
  32. {"wang wu", 52},
  33. {"zhao liu", 26},
  34. }
  36. fmt.Println(people)
  38. sort.Sort(PersonWrapper{people, func (p, q *Person) bool {
  39. return q.Age < p.Age // Age 遞減排序
  40. }})
  42. fmt.Println(people)
  43. sort.Sort(PersonWrapper{people, func (p, q *Person) bool {
  44. return p.Name < q.Name // Name 遞增排序
  45. }})
  47. fmt.Println(people)
  49. }

方法 2 將 [] Person 和比較的準則 cmp 封裝在了一起，形成了 PersonWrapper 函數，然後在其上綁定 Len 、 Less 和 Swap 方法。 實際上 sort.Sort(pw) 排序的是 pw 中的 people， 這就是前面說的， go 的排序未必就是針對的一個數組或是 slice， 而可以是一個對象中的數組或是 slice 。

結構體排序方法 3

me 趕腳方法 2 已經很不錯了， 唯一一個缺點是，在 main 中使用的時候暴露了 sort.Sort 的使用，還有就是 PersonWrapper 的構造。 為了讓 main 中使用起來更為方便， me 們可以再簡單的封裝一下， 構造一個 SortPerson 方法， 如下：

  1. package main
  3. import (
  4. "fmt"
  5. "sort"
  6. )
  8. type Person struct {
  9. Name string // 姓名
  10. Age int // 年紀
  11. }
  13. type PersonWrapper struct {
  14. people [] Person
  15. by func(p, q * Person) bool
  16. }
  18. type SortBy func(p, q *Person) bool
  20. func (pw PersonWrapper) Len() int { // 重寫 Len() 方法
  21. return len(pw.people)
  22. }
  23. func (pw PersonWrapper) Swap(i, j int){ // 重寫 Swap() 方法
  24. pw.people[i], pw.people[j] = pw.people[j], pw.people[i]
  25. }
  26. func (pw PersonWrapper) Less(i, j int) bool { // 重寫 Less() 方法
  27. return pw.by(&pw.people[i], &pw.people[j])
  28. }
  31. func SortPerson(people [] Person, by SortBy){ // SortPerson 方法
  32. sort.Sort(PersonWrapper{people, by})
  33. }
  35. func main() {
  36. people := [] Person{
  37. {"zhang san", 12},
  38. {"li si", 30},
  39. {"wang wu", 52},
  40. {"zhao liu", 26},
  41. }
  43. fmt.Println(people)
  45. sort.Sort(PersonWrapper{people, func (p, q *Person) bool {
  46. return q.Age < p.Age // Age 遞減排序
  47. }})
  49. fmt.Println(people)
  51. SortPerson(people, func (p, q *Person) bool {
  52. return p.Name < q.Name // Name 遞增排序
  53. })
  55. fmt.Println(people)
  57. }

在方法 2 的基礎上構造了 SortPerson 函數，使用的時候傳過去一個 [] Person 和一個 cmp 函數。

結構體排序方法 4

下面是另外一個實現思路， 可以說是方法 1、 2 的變體。

  1. package main
  3. import (
  4. "fmt"
  5. "sort"
  6. )
  8. type Person struct {
  9. Name string
  10. Weight int
  11. }
  13. type PersonSlice []Person
  15. func (s PersonSlice) Len() int { return len(s) }
  16. func (s PersonSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
  18. type ByName struct{ PersonSlice } // 將 PersonSlice 包裝起來到 ByName 中
  20. func (s ByName) Less(i, j int) bool { return s.PersonSlice[i].Name < s.PersonSlice[j].Name } // 將 Less 綁定到 ByName 上
  23. type ByWeight struct{ PersonSlice } // 將 PersonSlice 包裝起來到 ByWeight 中
  24. func (s ByWeight) Less(i, j int) bool { return s.PersonSlice[i].Weight < s.PersonSlice[j].Weight } // 將 Less 綁定到 ByWeight 上
  26. func main() {
  27. s := []Person{
  28. {"apple", 12},
  29. {"pear", 20},
  30. {"banana", 50},
  31. {"orange", 87},
  32. {"hello", 34},
  33. {"world", 43},
  34. }
  36. sort.Sort(ByWeight{s})
  37. fmt.Println("People by weight:")
  38. printPeople(s)
  40. sort.Sort(ByName{s})
  41. fmt.Println("\nPeople by name:")
  42. printPeople(s)
  44. }
  46. func printPeople(s []Person) {
  47. for _, o := range s {
  48. fmt.Printf("%-8s (%v)\n", o.Name, o.Weight)
  49. }
  50. }

對結構體的排序， 暫時就到這裏。 第一種排序對只根據一個字段的比較合適， 另外三個是針對可能根據多個字段排序的。方法 4 me 認為每次都要多構造一個 ByXXX ， 頗為不便， 這樣多麻煩，不如方法 2 和方法 3 來的方便，直接傳進去一個 cmp ，然後 okay 。 2、 3 沒有太大的差別， 3 只是簡單封裝了一下而已， 對於使用者來說， 可能會更方便一些，而且也會更少的出錯。

go語言的排序、結構體排序

相關推薦

go語言的排序、結構體排序

sea 封裝 class 讓其 其他 zhang import 過去 blue 原文：https://studygolang.com/articles/1598 晚上準備動手寫點 go 的程序的時候，想起 go 如何排序的問題。排序 sort 是個基本的操作，當然搜索

EXCEL排序(sort結構體排序）

                                                                                                                             EXCEL排序 Ex

關於Go語言,自定義結構體標籤的一個妙用.

在Go中首字母大小寫,決定著這此變數是否能被外部呼叫, 例如：在使用標準庫的json編碼自定一的結構的時候： <pre style="margin-top: 0px; margin-bottom: 0px;"><span style=" font-weig

Go語言教程之結構體

Hello，大家好，我是小棧君，最近因為工作的事情延誤了一點分享的進度，但是我會盡量抽時間分享關於IT乾貨知識，還希望大家能夠持續關注“IT乾貨棧”哦。 閒話不多說，今天給大家繼續分享關於Go語言的教程知識之結構體。 物件 在介紹結構體之前，我們先講講程式語言中的物件的概念吧，因為在相關的程式開發過程中，我們

Go語言基礎之結構體(面向物件程式設計上)

1 自定義型別和類型別名 1.1 自定義型別 Go語言中可以基於一些基本的資料型別，使用type關鍵字定義自定義型別的資料 。 自定義型別定義了一個全新的型別，該新型別具有基本資料型別的特性。自定義型別定義的方法如下： type TypeName Type //將 NewType定義為int 型別 type

golang | Go語言入門教程——結構體初始化與繼承

本文始發於個人公眾號：**TechFlow**，原創不易，求個關注 今天是golang專題第10篇文章，我們繼續來看golang當中的面向物件部分。 在上一篇文章當中我們一起學習了怎麼建立一個結構體，以及怎麼給結構體定義函式，還有函式接收者的使用。今天我們來學習一下結構體本身的一些使用方法。 初始化 在

GO語言為結構體排序

readdir clas package post ng- rac [] util amp package main import ( "fmt" "io/ioutil" "sort" "

go語言初體驗（流程控制、range遍歷、函式、結構體、面向物件）

一、流程控制 // main package main import ( "fmt" ) func main() { x := 2 switch x { case 1: fmt.Print("beifeng 1") case 2:

go語言初體驗（流程控制、range遍歷、函數、結構體、面向對象）

需要 3.3 fmt float compute 捕獲異常 value 地址 異常處理 一、流程控制 // main package main import ( "fmt" ) func main() { x := 2 switch x {

c語言中使用自帶的qsort（結構體排序）

c中沒有自帶的sort函式emm 不過有自帶的qsort函式 （其實用法都差不多（只是我經常以為c中有sort 標頭檔案要用  1 #include <stdlib.h>  一定要重新把指標指向的值賦值給一個node型別，不然比較不了 1 struct node{ 2 int d,i

ACMNO.43 C語言-成績排序 利用結構體解決，是一個進步啦！

題目描述 現有有N個學生的資料記錄，每個記錄包括學號、姓名、三科成績。 編寫一個函式input,用來輸入一個學生的資料記錄。 編寫一個函式print,列印一個學生的資料記錄。 在主函式呼叫這兩個函式，讀取N條記錄輸入，再按要求輸出。 N<100 輸入 學生數量N佔

C語言 · 運用結構體的排序方法

har order best detail 成績 sco ade -m 指向函數的指針 AllSight C語言 · 運用結構體的排序方法 　　之前遇到排序只想著最原始的方法，諸如冒泡，選擇，快速排序等等，剛剛跟大牛學會了結構體的方法來排序，這樣的話以後

C語言：對結構體變數進行氣泡排序

C語言：對結構體變數進行氣泡排序 我是一名在校大學生，初次寫部落格，希望各位大佬不喜勿噴，這個小程式，僅供參考，希望對大家有所幫助。 分析題意： 1.定義結構體變數，並給變數賦值 2.使用氣泡排序進行排序。 定義： 1.Input()函式，接收使用者輸入的值。 2.Output()函

Go語言學習筆記(五)-其他型別(指標、結構體、、)

指標 在Go語言中也存在指標，且指標儲存了變數的地址，初始值為nil。定義指標與定義變數相似，不同的是在型別前面指標需要加*例如: var p *int //此處定義了一個int型別的指標 指標也可以通過已有變數獲取，通過&操作符便可，與C

Go語言冒泡、選擇、插入、快速排序實戰淺析

Hello，各位小夥伴大家好，我是小棧君，今天為大家帶來的分享是關於go語言中的排序實戰淺析。 我們就實際操作關於go的氣泡排序、選擇排序、插入排序和快速排序四種方式的理論和實戰進行分享，希望能夠為大家在學習的路上帶來點啟發和經驗。 排序在我們平時的程式設計工作中時常可以見到，以按照不同的規則進行排序返回，以

水果，一道對結構體排序的水題

呵呵 print mes problem net 空行 沒有 scanf http 題目鏈接：https://vjudge.net/contest/161356#problem/E 夏天來了~~好開心啊,呵呵,好多好多水果~~ Joe經營著一個不大的水果店.他認為生存之道就

C語言：constkeyword、結構體

data con post -s 標簽 初始化 weight 什麽 聯系 前幾節內容的解說，主要是內存地址及指針的分析。這一節解說一下easy混淆的keywordconstant及結構體的知識。 一、constkeyword 1. 字符常量的指針 char const

JustOj 2039: 成績排名 （結構體排序）

string typedef node 感覺 pac 自己 lib esp 3.1 題目描述 每次期末考試成績出來之前的一段時間大豪哥心裏都是痛苦的，總感覺自己會在班上排名特別差。所以當成績出來以後大豪哥想快點知道班上的總排名，以便知道自己的排名。（PS：大豪哥班上有

洛谷 P1583 魔法照片【二級排序/結構體排序】

+= 優先 open ret amp 技術分享 -s span mil 題目描述 一共有n（n≤20000）個人（以1--n編號）向佳佳要照片，而佳佳只能把照片給其中的k個人。佳佳按照與他們的關系好壞的程度給每個人賦予了一個初始權值W[i]。然後將初始權值從大到小進

在路上---學習篇（一）Python 數據結構和算法 (4) --希爾排序、歸並排序

改進 randint 循環 打印 中一 隨機 關鍵詞 shel 條件 獨白： 　　希爾排序是經過優化的插入排序算法，之前所學的排序在空間上都是使用列表本身。而歸並排序是利用增加新的空間，來換取時間復雜度的減少。這倆者理念完全不一樣，註定造成的所消耗的時間不同以及空間上的不同