Sorting is a common operation in programming, and Go provides several options for sorting slices and arrays. In this article, we will look at how to sort an array in Go.

Step 1: Choose a sorting algorithm

The first step in sorting an array in Go is to choose a sorting algorithm. Go provides several built-in algorithms for sorting slices, including sort.Ints, sort.Float64s, and sort.Strings, among others. These functions use a variety of algorithms, including quicksort, mergesort, and heapsort, depending on the type of data being sorted.

For example, to sort an array of integers using the sort.Ints function, you would do something like this:

1
2
3
4
5
6
7
import "sort"

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

Step 2: Implement a custom sort function

If the built-in sorting functions do not meet your needs, you can implement your own custom sort function using the sort package. To do this, you will need to define a custom type that implements the sort.Interface interface, which requires three methods: Len, Less, and Swap.

For example, to sort an array of custom structs by a specific field, you might do something like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import "sort"

type Person struct {
  Name string
  Age  int
}

type ByAge []Person

func (a ByAge) Len() int           { return len(a) }

func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }

func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

func main() {
  people := []Person{
    {"Bob", 31},
    {"John", 42},
    {"Michael", 17},
    {"Jenny", 26},
  }
  sort.Sort(ByAge(people))
  fmt.Println(people)
  // [{Michael 17} {Jenny 26} {Bob 31} {John 42}]
}

Step 3: Sort a slice (Use the “sort.Slice” function)

Go 1.8 introduced the sort.Slice function, which provides a more concise and flexible way to sort slices. This function takes a slice and three optional compare functions as arguments, and it sorts the slice in place using these compare functions.

For example, to sort an array of custom structs by multiple fields using sort.Slice, you might do something like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import "sort"

type Person struct {
	Name string
	Age  int
	City string
}

func main() {
	people := []Person{
		{"Alice", 25, "New York"},
		{"Bob", 30, "Chicago"},
		{"Eve", 20, "New York"},
	}

	sort.Slice(people, func(i, j int) bool {
		if people[i].City != people[j].City {
			return people[i].City < people[j].City
		}
		return people[i].Age < people[j].Age
	})
	fmt.Println(people)  // [{Bob 30 Chicago} {Eve 20 New York} {Alice 25 New York}]
}

Conclusion

Sorting arrays and slices is a common operation in Go, and Go provides several options for doing so, including built-in functions and the “sort.Slice” function. By using these tools, you can easily and efficiently sort your data in Go.