Hello, and welcome back! Our journey today takes us into the sorting universe in Go. We will learn about and utilize a few of Go’s built-in sorting functions sort.Ints() and sort.Strings(), as well as other tools from the sort package. These functions significantly simplify the task of sorting data in Go. Let's get started!

Sorting refers to arranging data in a specific order, which enhances the efficiency of search or merge operations on said data. In real life, we sort books alphabetically or clothes by size. Similar concepts are applicable in programming, where sorting large lists of data for more effective analysis is a frequent practice.

Go offers the sort package that provides various methods for sorting slices of data. Let's dive into some examples.

Sorting with sort.Ints() and sort.Strings() makes sorting slices of these data types straightforward. Let's see them in action!

Sorting Slices of Integers

Go
Copy to clipboard
1package main
2
3import (
4    "fmt"
5    "sort"
6)
7
8func main() {
9    arr := []int{4, 1, 3, 2}
10    sort.Ints(arr)
11    fmt.Println(arr) // Output: [1 2 3 4]
12}

Sorting Slices of Strings

Go
Copy to clipboard
1package main
2
3import (
4    "fmt"
5    "sort"
6)
7
8func main() {
9    inventory := []string{"Bananas", "Pears", "Apples", "Dates"}
10    sort.Strings(inventory)
11    for _, item := range inventory {
12        fmt.Println(item)
13    }
14    // Output:
15    // Apples
16    // Bananas
17    // Dates
18    // Pears
19}

As you can see, sorting in Go is just that simple!

Go allows us to define custom sorting logic using the sort.Slice() function. Let's sort a slice of students by their grades, with alphabetical sorting applied in the event of ties in grades. First, let's define the Student struct:

Go
Copy to clipboard
1package main
2
3import (
4    "fmt"
5    "sort"
6)
7
8type Student struct {
9    Name  string
10    Grade int
11}
12
13func main() {
14    students := []Student{
15        {"Alice", 85},
16        {"Bob", 90},
17        {"Charlie", 90},
18    }
19
20    // Sort students by Grade in descending order
21    // If Grades are equal, sort by Name in alphabetical order
22    sort.Slice(students, func(i, j int) bool {
23        if students[i].Grade != students[j].Grade {
24            return students[i].Grade > students[j].Grade
25        }
26        return students[i].Name < students[j].Name
27    })
28
29    // Print sorted students
30    for _, student := range students {
31        fmt.Printf("%s:%d\n", student.Name, student.Grade)
32    }
33    // Output:
34    // Bob:90
35    // Charlie:90
36    // Alice:85
37}

In this example, we define a comparator function to sort the students slice primarily by grades in descending order and names alphabetically in case of ties.

To sort students by grades in ascending order but names in descending order in case of ties, adjust the comparator function within sort.Slice():

Go
Copy to clipboard
1sort.Slice(students, func(i, j int) bool {
2    if students[i].Grade != students[j].Grade {
3        return students[i].Grade < students[j].Grade
4    }
5    return students[i].Name > students[j].Name
6})
7    // Output:
8    // Alice:85
9    // Charlie:90
10    // Bob:90

The custom comparator now sorts grades in ascending order and names in descending order during grade ties.

Well done! You've learned how Go's sorting functions work and have utilized the sort package's built-in functions, including custom sorting with sort.Slice().

In our future lessons, we'll delve deeper into sorting and tackle more intricate problems, such as finding the K-th largest number. So, stay tuned and get ready to sort your way to success! Happy coding!