Golang 如何对切片进行排序

在Golang中，切片是一种非常常用的数据结构，而对切片进行排序也常常会用到。本文将介绍在Golang中如何对切片进行排序，以及如何使用不同的排序函数。

Golang中的排序函数

Golang中内置了sort包，其中包含了多种排序函数，如下所示：

func Ints(a []int)          // 对int类型的切片进行排序
func Float64s(a []float64)  // 对float64类型的切片进行排序
func Strings(a []string)    // 对string类型的切片进行排序
func Interfaces(a []interface{ // 对interface{}类型的切片进行排序
  Less(i, j int) bool       // 该函数返回是否应该将第i个元素放在第j个元素之前
})
func Slice(slice interface{}, less func(i, j int) bool)  // 对任意类型的切片进行排序

以上函数中，最常用的是Ints、Float64s和Strings函数，它们可以直接对对应类型的切片进行排序。如果要对其他类型的切片进行排序，可以使用Slice函数。

下面我们来看一些使用示例：

对Ints进行排序

package main

import (
    "fmt"
    "sort"
)

func main() {
    ints := []int{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
    sort.Ints(ints)
    fmt.Println(ints)  // 输出 [1 1 2 3 3 4 5 5 5 6 9]
}

对Float64s进行排序

package main

import (
    "fmt"
    "sort"
)

func main() {
    float64s := []float64{3.14, 2.71, 1.41, 3.00, 2.23}
    sort.Float64s(float64s)
    fmt.Println(float64s)  // 输出 [1.41 2.23 2.71 3 3.14]
}

对Strings进行排序

package main

import (
    "fmt"
    "sort"
)

func main() {
    strings := []string{"peach", "banana", "kiwi"}
    sort.Strings(strings)
    fmt.Println(strings)  // 输出 [banana kiwi peach]
}

对Interfaces进行排序

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

type People []Person

func (p People) Len() int           { return len(p) }
func (p People) Less(i, j int) bool { return p[i].age < p[j].age }
func (p People) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

func main() {
    people := People{
        {"bob", 31},
        {"john", 42},
        {"michael", 17},
        {"jenny", 26},
    }

    sort.Sort(people)
    fmt.Println(people)
}

对任意类型的切片进行排序

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

type People []Person

func (p People) Len() int           { return len(p) }
func (p People) Less(i, j int) bool { return p[i].age < p[j].age }
func (p People) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

type Car struct {
    brand string
    price int
}

func (c Car) String() string {
    return fmt.Sprintf("%s: %d", c.brand, c.price)
}

type Cars []Car

func (c Cars) Len() int           { return len(c) }
func (c Cars) Less(i, j int) bool { return c[i].price < c[j].price }
func (c Cars) Swap(i, j int)      { c[i], c[j] = c[j], c[i] }

func main() {
    people := People{
        {"bob", 31},
        {"john", 42},
        {"michael", 17},
        {"jenny", 26},
    }

    sort.Sort(people)
    fmt.Println(people)

    cars := Cars{
        {"bmw", 50000},
        {"benz", 70000},
        {"audi", 40000},
        {"lexus", 55000},
    }

    sort.Slice(cars, func(i, j int) bool {
        return cars[i].price < cars[j].price
    })

    fmt.Println(cars)
}

在使用Slice函数对任意类型的切片进行排序时，需要使用回调函数less来判断哪个元素应该放在前面。回调函数less应该返回一个bool值，表示第i个元素是否应该放在第j个元素之前。