快捷導(dǎo)航

Go?sort.Interface的基本使用

更新時間：2026年04月14日 08:57:50 作者：Go_error

本文主要介紹了Go?sort.Interface的基本使用,及對不同類型的數(shù)據(jù)進(jìn)行排序,包括字符串切片、結(jié)構(gòu)體切片等,并提供了具體示例,具有一定的參考價值,感興趣的可以了解一下

sort.Interface

Go 語言的 sort.Sort 函數(shù)不會對具體的序列和它的元素做任何假設(shè)。它使用了一個接口類型 sort.Interface 來指定通用的排序算法和可能被排序到的序列類型之間的約定。

一個內(nèi)置的排序算法需要知道三個東西：序列的長度，表示兩個元素比較的結(jié)果，一種交換兩個元素的方式； 這就是 sort.Interface 的三個方法：

package sort
type Interface interface {
 Len() int
 Less(i, j int) bool
 Swap(i, j int)
}

為了對序列進(jìn)行排序，我們需要定義一個實現(xiàn)了這三個方法的類型，然后對這個類型的一個實例應(yīng)用 sort.Sort 函數(shù)。

思考對一個字符串切片進(jìn)行排序，這可能是最簡單的例子了。下面是實現(xiàn)了一個新的類型 StringSlice 和它的 Len，Less 和 Swap 方法：

type StringSlice []string
func (x StringSlice) Len() int           { return len(x) }
func (x StringSlice) Less(i, j int) bool { return x[i] < x[j] }
func (x StringSlice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
func main() {
 s := []string{"a", "c", "b"}
 sort.Sort(StringSlice(s))
 fmt.Println(s) // [a b c]
}

現(xiàn)在我們可以通過像下面這樣將一個切片轉(zhuǎn)換為一個 StringSlice類型來進(jìn)行排序：

 sort.Sort(StringSlice(s))

上述 Less 方法中 " < " 代表按升序排序。

基礎(chǔ)類型的切片排序

對字符串切片的排序是很常用的需要，所以 sort 包直接提供了 StringSlice 類型：

 s := []string{"a", "c", "b"}
 sort.Sort(sort.StringSlice(s))

也提供了 Strings 函數(shù)能讓上面這些調(diào)用簡化成：

 s := []string{"a", "c", "b"}
 sort.Strings(s)

總結(jié)一下，對于 []int, []float64, []string 這種元素類型是基礎(chǔ)類型的切片，使用 sort 包提供的下面幾個函數(shù)進(jìn)行排序。

sort.Ints
sort.Floats
sort.Strings

結(jié)構(gòu)體元素類型切片排序

現(xiàn)在有一個元素類型為 Person 結(jié)構(gòu)體的切片，結(jié)構(gòu)體對象有 Name，Score，Age 字段，現(xiàn)按照 Name 進(jìn)行排序：

type Person struct {
 Name  string
 Score int
 Age   int
}
type Persons []Person
func (p Persons) Len() int           { return len(p) }
func (p Persons) Less(i, j int) bool { return p[i].Name < p[j].Name }
func (p Persons) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func main() {
 p := Persons{
  {"c", 90, 30},
  {"b", 100, 10},
  {"c", 90, 20},
 }
 sort.Sort(p)
 fmt.Println(p) // [{b 100 10} {c 90 30} {c 90 20}]
}

新增需求如果 Name 相同，按 Score 排序，Score 相同，按 Age 排序，修改 Less 方法：

type Person struct {
 Name  string
 Score int
 Age   int
}
type Persons []Person
func (p Persons) Len() int { return len(p) }
func (p Persons) Less(i, j int) bool {
 if p[i].Name != p[j].Name {
  return p[i].Name < p[j].Name
 }
 if p[i].Score != p[j].Score {
  return p[i].Score < p[j].Score
 }
 return p[i].Age < p[j].Age
}
func (p Persons) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func main() {
 p := Persons{
  {"c", 90, 30},
  {"b", 100, 10},
  {"c", 90, 20},
 }
 sort.Sort(p)
 fmt.Println(p) // [{b 100 10} {c 90 20} {c 90 30}]
}

可以使用 sort.Slice 進(jìn)一步簡化，該函數(shù)默認(rèn)實現(xiàn)了排序所需要的 Len 和 Swap 方法，傳入排序?qū)ο蠛?Less 方法即可：

 p := Persons{
  {"c", 90, 30},
  {"b", 100, 10},
  {"c", 90, 20},
 }
 sort.Slice(p, func(i, j int) bool {
  if p[i].Name != p[j].Name {
   return p[i].Name < p[j].Name
  }
  if p[i].Score != p[j].Score {
   return p[i].Score < p[j].Score
  }
  return p[i].Age < p[j].Age
 })
 fmt.Println(p) // [{b 100 10} {c 90 20} {c 90 30}]

任意數(shù)據(jù)結(jié)構(gòu)排序

實現(xiàn)了 sort.Interface 的具體類型不一定是切片類型，下面為PersonSort 結(jié)構(gòu)體類型實現(xiàn)排序接口：

type Person struct {
 Name  string
 Score int
 Age   int
}
type PersonSort struct {
 p    []Person
 less func(i, j Person) bool
}
func (p PersonSort) Len() int { return len(p.p) }
func (p PersonSort) Less(i, j int) bool { return p.less(p.p[i], p.p[j]) }
func (p PersonSort) Swap(i, j int) { p.p[i], p.p[j] = p.p[j], p.p[i] }
func main() {
 p := []Person{
  {"c", 90, 30},
  {"b", 100, 10},
  {"c", 90, 20},
 }
 less := func(i, j Person) bool {
  if i.Name != j.Name {
   return i.Name < j.Name
  }
  if i.Score != j.Score {
   return i.Score < j.Score
  }
  return i.Age < j.Age
 }
 sort.Sort(PersonSort{p, less})
 fmt.Println(p) // [{b 100 10} {c 90 20} {c 90 30}]
}

到此這篇關(guān)于Go sort.Interface的基本使用的文章就介紹到這了,更多相關(guān)Go sort.Interface內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: