package sort

Import Path
	sort (on golang.org and go.dev)

Dependency Relation
	imports one package, and imported by 24 packages

Involved Source Files
	    search.go
	    slice.go
	    slice_go113.go
	d-> sort.go
	    zfuncversion.go

Exported Type Names

	 type Float64Slice ([])
		Float64Slice attaches the methods of Interface to []float64, sorting in increasing order
		(not-a-number values are treated as less than other values).

		Exported Methods (5)
			 (T) Len() int
			 (T) Less(i, j int) bool
			 (T) Search(x float64) int
			 (T) Sort()
			 (T) Swap(i, j int)
		Implements (1+)
			 T : Interface
	 type Interface (interface)
		A type, typically a collection, that satisfies sort.Interface can be
		sorted by the routines in this package. The methods require that the
		elements of the collection be enumerated by an integer index.

		Exported Methods (3)
			 (T) Len() int
			 (T) Less(i, j int) bool
			 (T) Swap(i, j int)
		Implemented By (5+)
			Float64Slice
			IntSlice
			StringSlice
			go/scanner.ErrorList
			internal/fmtsort.(*SortedMap)
		As Outputs Of (1+)
			func Reverse(data Interface) Interface
		As Inputs Of (4+)
			func IsSorted(data Interface) bool
			func Reverse(data Interface) Interface
			func Sort(data Interface)
			func Stable(data Interface)
	 type IntSlice ([])
		IntSlice attaches the methods of Interface to []int, sorting in increasing order.

		Exported Methods (5)
			 (T) Len() int
			 (T) Less(i, j int) bool
			 (T) Search(x int) int
			 (T) Sort()
			 (T) Swap(i, j int)
		Implements (1+)
			 T : Interface
	 type StringSlice ([])
		StringSlice attaches the methods of Interface to []string, sorting in increasing order.

		Exported Methods (5)
			 (T) Len() int
			 (T) Less(i, j int) bool
			 (T) Search(x string) int
			 (T) Sort()
			 (T) Swap(i, j int)
		Implements (1+)
			 T : Interface
Exported Values

	 func Float64s(a []float64)
		Float64s sorts a slice of float64s in increasing order
		(not-a-number values are treated as less than other values).
	 func Float64sAreSorted(a []float64) bool
		Float64sAreSorted tests whether a slice of float64s is sorted in increasing order
		(not-a-number values are treated as less than other values).
	 func Ints(a []int)
		Ints sorts a slice of ints in increasing order.
	 func IntsAreSorted(a []int) bool
		IntsAreSorted tests whether a slice of ints is sorted in increasing order.
	 func IsSorted(data Interface) bool
		IsSorted reports whether data is sorted.
	 func Reverse(data Interface) Interface
		Reverse returns the reverse order for data.
	 func 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)
			}
	 func 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.
	 func 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.
	 func 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(slice interface{}, less func(i, j int) bool)
		Slice sorts the provided slice given the provided less function.

		The sort is not guaranteed to be stable. For a stable sort, use
		SliceStable.

		The function panics if the provided interface is not a slice.
	 func SliceIsSorted(slice interface{}, less func(i, j int) bool) bool
		SliceIsSorted tests whether a slice is sorted.

		The function panics if the provided interface is not a slice.
	 func SliceStable(slice interface{}, less func(i, j int) bool)
		SliceStable sorts the provided slice given the provided less
		function while keeping the original order of equal elements.

		The function panics if the provided interface is not a slice.
	 func Sort(data Interface)
		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.
	 func Stable(data Interface)
		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.
	 func Strings(a []string)
		Strings sorts a slice of strings in increasing order.
	 func StringsAreSorted(a []string) bool
		StringsAreSorted tests whether a slice of strings is sorted in increasing order.

The pages are generated with Golds v0.1.6. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project and 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.