How to use sort package for sorting in golang

The sorting implementation in the Go language is mainly implemented through the sort package. The sort package provides a standard sorting interface so that we can easily sort different types of data. This article will introduce how to use the sort package for sorting in golang.

Implementation principle of sort package

The sort package mainly implements sorting through the sort.Interface interface. It has three methods:

• Len() int: Returns the desired The number of elements to be sorted.
• Less(i, j int) bool: If element i should be ranked in front of element j, return true; otherwise, return false.
• Swap(i, j int): Swap the positions of elements i and j.

The sort package provides the following functions for sorting:

• func Ints(a []int): Sort int type slices in ascending order.
• func Float64s(a []float64): Sort float64 type slices in ascending order.
• func Strings(a []string): Sort string type slices in ascending order.
• func IntsAreSorted(a []int) bool: Determine whether the int type slice has been sorted.
• func Float64sAreSorted(a []float64) bool: Determine whether float64 type slices have been sorted.
• func StringsAreSorted(a []string) bool: Determine whether the string type slice has been sorted.
• func Sort(data Interface): Sorts data that implements sort.Interface.

Sample code

The following is some sample code for sorting slices of int type:

package main

import (  
    "fmt"
    "sort"
)

func main() {  
    data := []int{9, 6, 3, 8, 5, 2, 7, 4, 1}
    sort.Ints(data)
    fmt.Println(data)
}

The output result is:

[1 2 3 4 5 6 7 8 9]

The following is a sample code for sorting using the sort.Interface interface:

package main  
import (  
    "fmt"
    "sort"
)

type Person struct {  
    Name string
    Age  int
}

type ByName []Person  
func (this ByName) Len() int {
    return len(this)
}
func (this ByName) Less(i, j int) bool {  
   return this[i].Name < this[j].Name
}
func (this ByName) Swap(i, j int) {  
   this[i], this[j] = this[j], this[i]
}

func main() {  
    people := []Person{
      {"Bob", 31},
      {"John", 42},
      {"Jane", 29},
      {"Michael", 17},
      {"Chris", 51},
      {"Sarah", 37},
    }
    sort.Sort(ByName(people))
    fmt.Println(people)
}

The output result is:

[{Bob 31} {Chris 51} {Jane 29} {John 42} {Michael 17} {Sarah 37}]

The above code first defines a Person structure and a ByName type. The ByName type implements three methods of the sort.Interface interface, which are used to tell the sort package how to compare two elements and how to exchange elements. Then a people variable is defined to store Person type data. Finally, the sort.Sort function is called to sort the people in ascending order by name and output the results.

Summary

This article introduces the method of using the sort package for sorting in golang, the implementation principle of the sort package, and some sample codes. For the data types to be sorted, we only need to implement the three methods in the sort.Interface interface. The sort package already provides sorting functions for common data types such as int, float64 and string. When using it, you only need to call Can.

The above is the detailed content of How to use sort package for sorting in golang. For more information, please follow other related articles on the PHP Chinese website!