`package `**sort**
Import Path
sort* (on golang.org and go.dev)*
Dependency Relation
imports one package, and imported by 43 packages
Involved Source Files
search.go
slice.go
slice_go113.go
Package sort provides primitives for sorting slices and user-defined collections.
zfuncversion.go
Package-Level Type Names* (total 4)*
Float64Slice implements Interface for a []float64, sorting in increasing order,
with not-a-number (NaN) values ordered before other values.
( T) Len() int
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]))
Search returns the result of applying SearchFloat64s to the receiver and x.
Sort is a convenience method: x.Sort() calls Sort(x).
( T) Swap(i, j int)
T : Interface
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.
Len is the number of elements in the collection.
Less reports whether the element with index i
must sort before the element with index j.
If both Less(i, j) and Less(j, i) are false,
then the elements at index i and j are considered equal.
Sort may place equal elements in any order in the final result,
while Stable preserves the original input order of equal elements.
Less must describe a transitive ordering:
- if both Less(i, j) and Less(j, k) are true, then Less(i, k) must be true as well.
- if both Less(i, j) and Less(j, k) are false, then Less(i, k) must be false as well.
Note that floating-point comparison (the < operator on float32 or float64 values)
is not a transitive ordering when not-a-number (NaN) values are involved.
See Float64Slice.Less for a correct implementation for floating-point values.
Swap swaps the elements with indexes i and j.
Float64Slice
IntSlice
StringSlice
container/heap.Interface *(interface)*
go/scanner.ErrorList
*internal/fmtsort.SortedMap
func Reverse(data **Interface**) **Interface**
func IsSorted(data **Interface**) bool
func Reverse(data **Interface**) **Interface**
func Sort(data **Interface**)
func Stable(data **Interface**)
Package-Level Functions* (total 17)*
Float64s sorts a slice of float64s in increasing order.
Not-a-number (NaN) values are ordered before other values.
Float64sAreSorted reports whether the slice x is sorted in increasing order,
with not-a-number (NaN) values before any other values.
Ints sorts a slice of ints in increasing order.
IntsAreSorted reports whether the slice x is sorted in increasing order.
IsSorted reports whether data is sorted.
Reverse returns the reverse order for data.
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)
}
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.
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.
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.
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.
SliceIsSorted reports whether the slice x is sorted according to the provided less function.
It panics if x is not a slice.
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.
Sort sorts data.
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.
Stable sorts data while keeping the original order of equal elements.
It makes one call to data.Len to determine n, O(n*log(n)) calls to
data.Less and O(n*log(n)*log(n)) calls to data.Swap.
Strings sorts a slice of strings in increasing order.
StringsAreSorted reports whether the slice x is sorted in increasing order.

The pages are generated with Golds v0.2.5. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds. |