Packages

sort

Package sort provides primitives for sorting slices and user-defined collections.

Index

Functions

func Float64s

1func Float64s(x []float64)

Float64s sorts a slice of float64s in increasing order. Not-a-number (NaN) values are ordered before other values. 

1s := []float64{5.2, -1.3, 0.7, -3.8, 2.6}
2sort.Float64s(s)
3fmt.Println(s)
4
5s = []float64{math.Inf(1), math.NaN(), math.Inf(-1), 0.0}
6sort.Float64s(s)
7fmt.Println(s)

Output

[-3.8 -1.3 0.7 2.6 5.2]
[NaN -Inf 0 +Inf]

func Float64sAreSorted

1func Float64sAreSorted(x []float64) bool

Float64sAreSorted reports whether the slice x is sorted in increasing order, with not-a-number (NaN) values before any other values. 

1s := []float64{0.7, 1.3, 2.6, 3.8, 5.2}
2fmt.Println(sort.Float64sAreSorted(s))
3
4s = []float64{5.2, 3.8, 2.6, 1.3, 0.7}
5fmt.Println(sort.Float64sAreSorted(s))
6
7s = []float64{5.2, 1.3, 0.7, 3.8, 2.6}
8fmt.Println(sort.Float64sAreSorted(s))

Output

true
false
false

func Ints

1func Ints(x []int)

Ints sorts a slice of ints in increasing order. 

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

Output

[1 2 3 4 5 6]

func IntsAreSorted

1func IntsAreSorted(x []int) bool

IntsAreSorted reports whether the slice x is sorted in increasing order. 

1s := []int{1, 2, 3, 4, 5, 6}
2fmt.Println(sort.IntsAreSorted(s))
3
4s = []int{6, 5, 4, 3, 2, 1}
5fmt.Println(sort.IntsAreSorted(s))
6
7s = []int{3, 2, 4, 1, 5}
8fmt.Println(sort.IntsAreSorted(s))

Output

true
false
false

func IsSorted

1func IsSorted(data Interface) bool

IsSorted reports whether data is sorted. 

1func Search(n int, f func(int) bool) int

Search uses binary search to find and return the smallest index i in [0, n) at which f(i) is true, assuming that on the range [0, n), f(i) == true implies f(i+1) == true. That is, Search requires that f is false for some (possibly empty) prefix of the input range [0, n) and then true for the (possibly empty) remainder; Search returns the first true index. If there is no such index, Search returns n. (Note that the "not found" return value is not -1 as in, for instance, strings.Index.) Search calls f(i) only for i in the range [0, n).

A common use of Search is to find the index i for a value x in a sorted, indexable data structure such as an array or slice. In this case, the argument f, typically a closure, captures the value to be searched for, and how the data structure is indexed and ordered.

For instance, given a slice data sorted in ascending order, the call Search(len(data), func(i int) bool { return data[i] >= 23 }) returns the smallest index i such that data[i] >= 23. If the caller wants to find whether 23 is in the slice, it must test data[i] == 23 separately.

Searching data sorted in descending order would use the <= operator instead of the >= operator.

To complete the example above, the following code tries to find the value x in an integer slice data sorted in ascending order:

x := 23
i := sort.Search(len(data), func(i int) bool { return data[i] >= x })
if i < len(data) && data[i] == x {
	// x is present at data[i]
} else {
	// x is not present in data,
	// but i is the index where it would be inserted.
}

As a more whimsical example, this program guesses your number:

func GuessingGame() {
	var s string
	fmt.Printf("Pick an integer from 0 to 100.\n")
	answer := sort.Search(100, func(i int) bool {
		fmt.Printf("Is your number <= %d? ", i)
		fmt.Scanf("%s", &s)
		return s != "" && s[0] == 'y'
	})
	fmt.Printf("Your number is %d.\n", answer)
}

This example demonstrates searching a list sorted in ascending order. 

1a := []int{1, 3, 6, 10, 15, 21, 28, 36, 45, 55}
2x := 6
3
4i := sort.Search(len(a), func(i int) bool { return a[i] >= x })
5if i < len(a) && a[i] == x {
6	fmt.Printf("found %d at index %d in %v\n", x, i, a)
7} else {
8	fmt.Printf("%d not found in %v\n", x, a)
9}

Output

found 6 at index 2 in [1 3 6 10 15 21 28 36 45 55]

This example demonstrates searching a list sorted in descending order. The approach is the same as searching a list in ascending order, but with the condition inverted. 

1a := []int{55, 45, 36, 28, 21, 15, 10, 6, 3, 1}
2x := 6
3
4i := sort.Search(len(a), func(i int) bool { return a[i] <= x })
5if i < len(a) && a[i] == x {
6	fmt.Printf("found %d at index %d in %v\n", x, i, a)
7} else {
8	fmt.Printf("%d not found in %v\n", x, a)
9}

Output

found 6 at index 7 in [55 45 36 28 21 15 10 6 3 1]

func SearchFloat64s

1func SearchFloat64s(a []float64, x float64) int

SearchFloat64s searches for x in a sorted slice of float64s and returns the index as specified by Search. The return value is the index to insert x if x is not present (it could be len(a)). The slice must be sorted in ascending order.

This example demonstrates searching for float64 in a list sorted in ascending order. 

1a := []float64{1.0, 2.0, 3.3, 4.6, 6.1, 7.2, 8.0}
2
3x := 2.0
4i := sort.SearchFloat64s(a, x)
5fmt.Printf("found %g at index %d in %v\n", x, i, a)
6
7x = 0.5
8i = sort.SearchFloat64s(a, x)
9fmt.Printf("%g not found, can be inserted at index %d in %v\n", x, i, a)

Output

found 2 at index 1 in [1 2 3.3 4.6 6.1 7.2 8]
0.5 not found, can be inserted at index 0 in [1 2 3.3 4.6 6.1 7.2 8]

func SearchInts

1func SearchInts(a []int, x int) int

SearchInts searches for x in a sorted slice of ints and returns the index as specified by Search. The return value is the index to insert x if x is not present (it could be len(a)). The slice must be sorted in ascending order.

This example demonstrates searching for int in a list sorted in ascending order. 

1a := []int{1, 2, 3, 4, 6, 7, 8}
2
3x := 2
4i := sort.SearchInts(a, x)
5fmt.Printf("found %d at index %d in %v\n", x, i, a)
6
7x = 5
8i = sort.SearchInts(a, x)
9fmt.Printf("%d not found, can be inserted at index %d in %v\n", x, i, a)

Output

found 2 at index 1 in [1 2 3 4 6 7 8]
5 not found, can be inserted at index 4 in [1 2 3 4 6 7 8]

func SearchStrings

1func SearchStrings(a []string, x string) int

SearchStrings searches for x in a sorted slice of strings and returns the index as specified by Search. The return value is the index to insert x if x is not present (it could be len(a)). The slice must be sorted in ascending order.

func Slice

1func Slice(x any, less func(i, j int) bool)

Slice sorts the slice x given the provided less function. It panics if x is not a slice.

The sort is not guaranteed to be stable: equal elements may be reversed from their original order. For a stable sort, use SliceStable.

The less function must satisfy the same requirements as the Interface type’s Less method.

 1people := []struct {
 2	Name	string
 3	Age	int
 4}{
 5	{"Gopher", 7},
 6	{"Alice", 55},
 7	{"Vera", 24},
 8	{"Bob", 75},
 9}
10sort.Slice(people, func(i, j int) bool { return people[i].Name < people[j].Name })
11fmt.Println("By name:", people)
12
13sort.Slice(people, func(i, j int) bool { return people[i].Age < people[j].Age })
14fmt.Println("By age:", people)

Output

By name: [{Alice 55} {Bob 75} {Gopher 7} {Vera 24}]
By age: [{Gopher 7} {Vera 24} {Alice 55} {Bob 75}]

func SliceIsSorted

1func SliceIsSorted(x any, less func(i, j int) bool) bool

SliceIsSorted reports whether the slice x is sorted according to the provided less function. It panics if x is not a slice.

func SliceStable

1func SliceStable(x any, less func(i, j int) bool)

SliceStable sorts the slice x using the provided less function, keeping equal elements in their original order. It panics if x is not a slice.

The less function must satisfy the same requirements as the Interface type’s Less method.

 1people := []struct {
 2	Name	string
 3	Age	int
 4}{
 5	{"Alice", 25},
 6	{"Elizabeth", 75},
 7	{"Alice", 75},
 8	{"Bob", 75},
 9	{"Alice", 75},
10	{"Bob", 25},
11	{"Colin", 25},
12	{"Elizabeth", 25},
13}
14
15sort.SliceStable(people, func(i, j int) bool { return people[i].Name < people[j].Name })
16fmt.Println("By name:", people)
17
18sort.SliceStable(people, func(i, j int) bool { return people[i].Age < people[j].Age })
19fmt.Println("By age,name:", people)

Output

By name: [{Alice 25} {Alice 75} {Alice 75} {Bob 75} {Bob 25} {Colin 25} {Elizabeth 75} {Elizabeth 25}]
By age,name: [{Alice 25} {Bob 25} {Colin 25} {Elizabeth 25} {Alice 75} {Alice 75} {Bob 75} {Elizabeth 75}]

func Sort

1func Sort(data Interface)

Sort sorts data in ascending order as determined by the Less method. It makes one call to data.Len to determine n and O(n*log(n)) calls to data.Less and data.Swap. The sort is not guaranteed to be stable.

func Stable

1func Stable(data Interface)

Stable sorts data in ascending order as determined by the Less method, while keeping the original order of equal elements.

It makes one call to data.Len to determine n, O(nlog(n)) calls to data.Less and O(nlog(n)*log(n)) calls to data.Swap.

func Strings

1func Strings(x []string)

Strings sorts a slice of strings in increasing order. 

1s := []string{"Go", "Bravo", "Gopher", "Alpha", "Grin", "Delta"}
2sort.Strings(s)
3fmt.Println(s)

Output

[Alpha Bravo Delta Go Gopher Grin]

func StringsAreSorted

1func StringsAreSorted(x []string) bool

StringsAreSorted reports whether the slice x is sorted in increasing order.

Types

type Float64Slice

1type Float64Slice []float64

Float64Slice implements Interface for a []float64, sorting in increasing order, with not-a-number (NaN) values ordered before other values.

func Len

1func (x Float64Slice) Len() int

func Less

1func (x Float64Slice) Less(i, j int) bool

Less reports whether x[i] should be ordered before x[j], as required by the sort Interface. Note that floating-point comparison by itself is not a transitive relation: it does not report a consistent ordering for not-a-number (NaN) values. This implementation of Less places NaN values before any others, by using: 

x[i] < x[j] || (math.IsNaN(x[i]) && !math.IsNaN(x[j]))

func Search

1func (p Float64Slice) Search(x float64) int

Search returns the result of applying SearchFloat64s to the receiver and x.

func Sort

1func (x Float64Slice) Sort()

Sort is a convenience method: x.Sort() calls Sort(x).

func Swap

1func (x Float64Slice) Swap(i, j int)

type IntSlice

1type IntSlice []int

IntSlice attaches the methods of Interface to []int, sorting in increasing order.

func Len

1func (x IntSlice) Len() int

func Less

1func (x IntSlice) Less(i, j int) bool

func Search

1func (p IntSlice) Search(x int) int

Search returns the result of applying SearchInts to the receiver and x.

func Sort

1func (x IntSlice) Sort()

Sort is a convenience method: x.Sort() calls Sort(x).

func Swap

1func (x IntSlice) Swap(i, j int)

type Interface

 1type Interface interface {
 2	// Len is the number of elements in the collection.
 3	Len() int
 4
 5	// Less reports whether the element with index i
 6	// must sort before the element with index j.
 7	//
 8	// If both Less(i, j) and Less(j, i) are false,
 9	// then the elements at index i and j are considered equal.
10	// Sort may place equal elements in any order in the final result,
11	// while Stable preserves the original input order of equal elements.
12	//
13	// Less must describe a transitive ordering:
14	//  - if both Less(i, j) and Less(j, k) are true, then Less(i, k) must be true as well.
15	//  - if both Less(i, j) and Less(j, k) are false, then Less(i, k) must be false as well.
16	//
17	// Note that floating-point comparison (the < operator on float32 or float64 values)
18	// is not a transitive ordering when not-a-number (NaN) values are involved.
19	// See Float64Slice.Less for a correct implementation for floating-point values.
20	Less(i, j int) bool
21
22	// Swap swaps the elements with indexes i and j.
23	Swap(i, j int)
24}

An implementation of Interface can be sorted by the routines in this package. The methods refer to elements of the underlying collection by integer index.

type StringSlice

1type StringSlice []string

StringSlice attaches the methods of Interface to []string, sorting in increasing order.

func Len

1func (x StringSlice) Len() int

func Less

1func (x StringSlice) Less(i, j int) bool

func Search

1func (p StringSlice) Search(x string) int

Search returns the result of applying SearchStrings to the receiver and x.

func Sort

1func (x StringSlice) Sort()

Sort is a convenience method: x.Sort() calls Sort(x).

func Swap

1func (x StringSlice) Swap(i, j int)

© Matthias Hochgatterer – Mastodon – Github – Résumé