Пакет sort
Обзор
Пакет sort предоставляет примитивы для сортировки срезов и пользовательских коллекций.
Пример
Код:
package sort_test
import (
"fmt"
"sort"
)
type Person struct {
Name string
Age int
}
func (p Person) String() string {
return fmt.Sprintf("%s: %d", p.Name, p.Age)
}
// ByAge implements sort.Interface for []Person based on
// the Age field.
type ByAge []Person
func (a ByAge) Len() int { return len(a) }
func (a ByAge) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
func Example() {
people := []Person{
{"Bob", 31},
{"John", 42},
{"Michael", 17},
{"Jenny", 26},
}
fmt.Println(people)
// There are two ways to sort a slice. First, one can define
// a set of methods for the slice type, as with ByAge, and
// call sort.Sort. In this first example we use that technique.
sort.Sort(ByAge(people))
fmt.Println(people)
// The other way is to use sort.Slice with a custom Less
// function, which can be provided as a closure. In this
// case no methods are needed. (And if they exist, they
// are ignored.) Here we re-sort in reverse order: compare
// the closure with ByAge.Less.
sort.Slice(people, func(i, j int) bool {
return people[i].Age > people[j].Age
})
fmt.Println(people)
// Output:
// [Bob: 31 John: 42 Michael: 17 Jenny: 26]
// [Michael: 17 Jenny: 26 Bob: 31 John: 42]
// [John: 42 Bob: 31 Jenny: 26 Michael: 17]
}
Пример (SortKeys)
ExampleSortKeys демонстрирует технику сортировки типа struct с использованием программируемых критериев сортировки.
Код:
package sort_test
import (
"fmt"
"sort"
)
// A couple of type definitions to make the units clear.
type earthMass float64
type au float64
// A Planet defines the properties of a solar system object.
type Planet struct {
name string
mass earthMass
distance au
}
// By is the type of a "less" function that defines the ordering of its Planet arguments.
type By func(p1, p2 *Planet) bool
// Sort is a method on the function type, By, that sorts the argument slice according to the function.
func (by By) Sort(planets []Planet) {
ps := &planetSorter{
planets: planets,
by: by, // The Sort method's receiver is the function (closure) that defines the sort order.
}
sort.Sort(ps)
}
// planetSorter joins a By function and a slice of Planets to be sorted.
type planetSorter struct {
planets []Planet
by func(p1, p2 *Planet) bool // Closure used in the Less method.
}
// Len is part of sort.Interface.
func (s *planetSorter) Len() int {
return len(s.planets)
}
// Swap is part of sort.Interface.
func (s *planetSorter) Swap(i, j int) {
s.planets[i], s.planets[j] = s.planets[j], s.planets[i]
}
// Less is part of sort.Interface. It is implemented by calling the "by" closure in the sorter.
func (s *planetSorter) Less(i, j int) bool {
return s.by(&s.planets[i], &s.planets[j])
}
var planets = []Planet{
{"Mercury", 0.055, 0.4},
{"Venus", 0.815, 0.7},
{"Earth", 1.0, 1.0},
{"Mars", 0.107, 1.5},
}
// ExampleSortKeys demonstrates a technique for sorting a struct type using programmable sort criteria.
func Example_sortKeys() {
// Closures that order the Planet structure.
name := func(p1, p2 *Planet) bool {
return p1.name < p2.name
}
mass := func(p1, p2 *Planet) bool {
return p1.mass < p2.mass
}
distance := func(p1, p2 *Planet) bool {
return p1.distance < p2.distance
}
decreasingDistance := func(p1, p2 *Planet) bool {
return distance(p2, p1)
}
// Sort the planets by the various criteria.
By(name).Sort(planets)
fmt.Println("By name:", planets)
By(mass).Sort(planets)
fmt.Println("By mass:", planets)
By(distance).Sort(planets)
fmt.Println("By distance:", planets)
By(decreasingDistance).Sort(planets)
fmt.Println("By decreasing distance:", planets)
// Output: By name: [{Earth 1 1} {Mars 0.107 1.5} {Mercury 0.055 0.4} {Venus 0.815 0.7}]
// By mass: [{Mercury 0.055 0.4} {Mars 0.107 1.5} {Venus 0.815 0.7} {Earth 1 1}]
// By distance: [{Mercury 0.055 0.4} {Venus 0.815 0.7} {Earth 1 1} {Mars 0.107 1.5}]
// By decreasing distance: [{Mars 0.107 1.5} {Earth 1 1} {Venus 0.815 0.7} {Mercury 0.055 0.4}]
}
Пример (SortMultiKeys)
ExampleMultiKeys демонстрирует технику сортировки типа struct с использованием различных наборов нескольких полей в сравнении. Мы объединяем функции "Less", каждая из которых сравнивает по одному полю.
Код:
package sort_test
import (
"fmt"
"sort"
)
// A Change is a record of source code changes, recording user, language, and delta size.
type Change struct {
user string
language string
lines int
}
type lessFunc func(p1, p2 *Change) bool
// multiSorter implements the Sort interface, sorting the changes within.
type multiSorter struct {
changes []Change
less []lessFunc
}
// Sort sorts the argument slice according to the less functions passed to OrderedBy.
func (ms *multiSorter) Sort(changes []Change) {
ms.changes = changes
sort.Sort(ms)
}
// OrderedBy returns a Sorter that sorts using the less functions, in order.
// Call its Sort method to sort the data.
func OrderedBy(less ...lessFunc) *multiSorter {
return &multiSorter{
less: less,
}
}
// Len is part of sort.Interface.
func (ms *multiSorter) Len() int {
return len(ms.changes)
}
// Swap is part of sort.Interface.
func (ms *multiSorter) Swap(i, j int) {
ms.changes[i], ms.changes[j] = ms.changes[j], ms.changes[i]
}
// Less is part of sort.Interface. It is implemented by looping along the
// less functions until it finds a comparison that discriminates between
// the two items (one is less than the other). Note that it can call the
// less functions twice per call. We could change the functions to return
// -1, 0, 1 and reduce the number of calls for greater efficiency: an
// exercise for the reader.
func (ms *multiSorter) Less(i, j int) bool {
p, q := &ms.changes[i], &ms.changes[j]
// Try all but the last comparison.
var k int
for k = 0; k < len(ms.less)-1; k++ {
less := ms.less[k]
switch {
case less(p, q):
// p < q, so we have a decision.
return true
case less(q, p):
// p > q, so we have a decision.
return false
}
// p == q; try the next comparison.
}
// All comparisons to here said "equal", so just return whatever
// the final comparison reports.
return ms.less[k](p, q)
}
var changes = []Change{
{"gri", "Go", 100},
{"ken", "C", 150},
{"glenda", "Go", 200},
{"rsc", "Go", 200},
{"r", "Go", 100},
{"ken", "Go", 200},
{"dmr", "C", 100},
{"r", "C", 150},
{"gri", "Smalltalk", 80},
}
// ExampleMultiKeys demonstrates a technique for sorting a struct type using different
// sets of multiple fields in the comparison. We chain together "Less" functions, each of
// which compares a single field.
func Example_sortMultiKeys() {
// Closures that order the Change structure.
user := func(c1, c2 *Change) bool {
return c1.user < c2.user
}
language := func(c1, c2 *Change) bool {
return c1.language < c2.language
}
increasingLines := func(c1, c2 *Change) bool {
return c1.lines < c2.lines
}
decreasingLines := func(c1, c2 *Change) bool {
return c1.lines > c2.lines // Note: > orders downwards.
}
// Simple use: Sort by user.
OrderedBy(user).Sort(changes)
fmt.Println("By user:", changes)
// More examples.
OrderedBy(user, increasingLines).Sort(changes)
fmt.Println("By user,<lines:", changes)
OrderedBy(user, decreasingLines).Sort(changes)
fmt.Println("By user,>lines:", changes)
OrderedBy(language, increasingLines).Sort(changes)
fmt.Println("By language,<lines:", changes)
OrderedBy(language, increasingLines, user).Sort(changes)
fmt.Println("By language,<lines,user:", changes)
// Output:
// By user: [{dmr C 100} {glenda Go 200} {gri Go 100} {gri Smalltalk 80} {ken C 150} {ken Go 200} {r Go 100} {r C 150} {rsc Go 200}]
// By user,<lines: [{dmr C 100} {glenda Go 200} {gri Smalltalk 80} {gri Go 100} {ken C 150} {ken Go 200} {r Go 100} {r C 150} {rsc Go 200}]
// By user,>lines: [{dmr C 100} {glenda Go 200} {gri Go 100} {gri Smalltalk 80} {ken Go 200} {ken C 150} {r C 150} {r Go 100} {rsc Go 200}]
// By language,<lines: [{dmr C 100} {ken C 150} {r C 150} {gri Go 100} {r Go 100} {glenda Go 200} {ken Go 200} {rsc Go 200} {gri Smalltalk 80}]
// By language,<lines,user: [{dmr C 100} {ken C 150} {r C 150} {gri Go 100} {r Go 100} {glenda Go 200} {ken Go 200} {rsc Go 200} {gri Smalltalk 80}]
}
Пример (SortWrapper)
Код:
package sort_test
import (
"fmt"
"sort"
)
type Grams int
func (g Grams) String() string { return fmt.Sprintf("%dg", int(g)) }
type Organ struct {
Name string
Weight Grams
}
type Organs []*Organ
func (s Organs) Len() int { return len(s) }
func (s Organs) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
// ByName implements sort.Interface by providing Less and using the Len and
// Swap methods of the embedded Organs value.
type ByName struct{ Organs }
func (s ByName) Less(i, j int) bool { return s.Organs[i].Name < s.Organs[j].Name }
// ByWeight implements sort.Interface by providing Less and using the Len and
// Swap methods of the embedded Organs value.
type ByWeight struct{ Organs }
func (s ByWeight) Less(i, j int) bool { return s.Organs[i].Weight < s.Organs[j].Weight }
func Example_sortWrapper() {
s := []*Organ{
{"brain", 1340},
{"heart", 290},
{"liver", 1494},
{"pancreas", 131},
{"prostate", 62},
{"spleen", 162},
}
sort.Sort(ByWeight{s})
fmt.Println("Organs by weight:")
printOrgans(s)
sort.Sort(ByName{s})
fmt.Println("Organs by name:")
printOrgans(s)
// Output:
// Organs by weight:
// prostate (62g)
// pancreas (131g)
// spleen (162g)
// heart (290g)
// brain (1340g)
// liver (1494g)
// Organs by name:
// brain (1340g)
// heart (290g)
// liver (1494g)
// pancreas (131g)
// prostate (62g)
// spleen (162g)
}
func printOrgans(s []*Organ) {
for _, o := range s {
fmt.Printf("%-8s (%v)\n", o.Name, o.Weight)
}
}
Индекс
Примеры
Файлы пакета
search.go slice.go sort.go sort_impl_go121.go zsortfunc.go zsortinterface.go
func Find 1.19
func Find(n int, cmp func(int) int) (i int, found bool)
Find использует бинарный поиск для поиска и возврата наименьшего индекса i в [0, n), в котором cmp(i) <= 0. Если такого индекса i нет, Find возвращает i = n. Результат found равен true, если i < n и cmp(i) == 0. Find вызывает cmp(i) только для i в диапазоне [0, n).
Для бинарного поиска Find требует, чтобы cmp(i) > 0 для начального префикса диапазона, cmp(i) == 0 в середине и cmp(i) < 0 для конечного суффикса диапазона. (Каждый поддиапазон может быть пустым.) Обычно это условие устанавливается путем интерпретации cmp(i) как сравнения целевого значения t с элементом i в базовой индексируемой структуре данных x, возвращая <0, 0 и >0, когда t < x[i], t == x[i] и t > x[i] соответственно.
Например, для поиска определённой строки в отсортированном списке строк:
i, found := sort.Find(x.Len(), func(i int) int {
return strings.Compare(target, x.At(i))
})
if found {
fmt.Printf("found %s at entry %d\n", target, i)
} else {
fmt.Printf("%s not found, would insert at %d", target, i)
}
Пример
Этот пример демонстрирует поиск строки в списке, отсортированном по возрастанию.
Код:
a := []string{"apple", "banana", "lemon", "mango", "pear", "strawberry"}
for _, x := range []string{"banana", "orange"} {
i, found := sort.Find(len(a), func(i int) int {
return strings.Compare(x, a[i])
})
if found {
fmt.Printf("found %s at index %d\n", x, i)
} else {
fmt.Printf("%s not found, would insert at %d\n", x, i)
}
}
Вывод:
found banana at index 1 orange not found, would insert at 4
func Float64s
func Float64s(x []float64)
Float64s сортирует срез float64 в порядке возрастания. Значения Not-a-number (NaN) упорядочиваются перед другими значениями.
Примечание: начиная с Go 1.22, эта функция просто вызывает slices.Sort.
Пример
Код:
s := []float64{5.2, -1.3, 0.7, -3.8, 2.6} // unsorted
sort.Float64s(s)
fmt.Println(s)
s = []float64{math.Inf(1), math.NaN(), math.Inf(-1), 0.0} // unsorted
sort.Float64s(s)
fmt.Println(s)
Вывод:
[-3.8 -1.3 0.7 2.6 5.2] [NaN -Inf 0 +Inf]
func Float64sAreSorted
func Float64sAreSorted(x []float64) bool
Float64sAreSorted сообщает, отсортирован ли срез x в порядке возрастания, при этом значения Not-a-number (NaN) находятся перед другими значениями.
Примечание: начиная с Go 1.22, эта функция просто вызывает slices.IsSorted.
Пример
Код:
s := []float64{0.7, 1.3, 2.6, 3.8, 5.2} // sorted ascending
fmt.Println(sort.Float64sAreSorted(s))
s = []float64{5.2, 3.8, 2.6, 1.3, 0.7} // sorted descending
fmt.Println(sort.Float64sAreSorted(s))
s = []float64{5.2, 1.3, 0.7, 3.8, 2.6} // unsorted
fmt.Println(sort.Float64sAreSorted(s))
Вывод:
true false false
func Ints
func Ints(x []int)
Ints сортирует срез целых чисел в порядке возрастания.
Примечание: начиная с Go 1.22, эта функция просто вызывает slices.Sort.
Пример
Код:
s := []int{5, 2, 6, 3, 1, 4} // unsorted
sort.Ints(s)
fmt.Println(s)
Вывод:
[1 2 3 4 5 6]
func IntsAreSorted
func IntsAreSorted(x []int) bool
IntsAreSorted сообщает, отсортирован ли срез x в порядке возрастания.
Примечание: начиная с Go 1.22, эта функция просто вызывает slices.IsSorted.
Пример
Код:
s := []int{1, 2, 3, 4, 5, 6} // sorted ascending
fmt.Println(sort.IntsAreSorted(s))
s = []int{6, 5, 4, 3, 2, 1} // sorted descending
fmt.Println(sort.IntsAreSorted(s))
s = []int{3, 2, 4, 1, 5} // unsorted
fmt.Println(sort.IntsAreSorted(s))
Вывод:
true false false
func IsSorted
func IsSorted(data Interface) bool
IsSorted сообщает, отсортированы ли данные.
Примечание: во многих ситуациях более удобной и быстрой функцией является slices.IsSortedFunc.
func Search
func Search(n int, f func(int) bool) int
Search использует бинарный поиск для поиска и возврата наименьшего индекса i в [0, n), в котором f(i) истинно, предполагая, что в диапазоне [0, n), f(i) == true подразумевает f(i+1) == true. То есть, Search требует, чтобы f было ложным для некоторого (возможно, пустого) префикса входного диапазона [0, n), а затем истинным для (возможно, пустого) оставшегося диапазона; Search возвращает первый индекс true. Если такого индекса нет, Search возвращает n. (Обратите внимание, что возвращаемое значение «не найдено» не равно -1, как, например, в strings.Index.) Search вызывает f(i) только для i в диапазоне [0, n).
Обычное использование Search заключается в поиске индекса i для значения x в отсортированной индексируемой структуре данных, такой как массив или срез. В этом случае аргумент f, обычно замыкание, содержит искомое значение и способ индексирования и упорядочивания структуры данных.
Например, для данного среза данных, отсортированного по возрастанию, вызов Search(len(data), func(i int) bool { return data[i] >= 23 }) возвращает наименьший индекс i такой, что data[i] >= 23. Если вызывающая сторона хочет проверить, содержится ли 23 в срезе, ей нужно дополнительно проверить data[i] == 23.
Поиск данных, отсортированных по убыванию, использует оператор <= вместо оператора >=.
Для завершения примера выше, следующий код пытается найти значение x в целочисленном срезе данных, отсортированном по возрастанию:
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.
}
Как более забавный пример, эта программа угадывает ваше число:
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)
}
Пример
Этот пример демонстрирует поиск в отсортированном списке по возрастанию.
Код:
a := []int{1, 3, 6, 10, 15, 21, 28, 36, 45, 55}
x := 6
i := sort.Search(len(a), func(i int) bool { return a[i] >= x })
if i < len(a) && a[i] == x {
fmt.Printf("found %d at index %d in %v\n", x, i, a)
} else {
fmt.Printf("%d not found in %v\n", x, a)
}
Вывод:
found 6 at index 2 in [1 3 6 10 15 21 28 36 45 55]
Пример (DescendingOrder)
Этот пример демонстрирует поиск в списке, отсортированном по убыванию. Подход такой же, как при поиске в списке по возрастанию, но с обращенным условием.
Код:
a := []int{55, 45, 36, 28, 21, 15, 10, 6, 3, 1}
x := 6
i := sort.Search(len(a), func(i int) bool { return a[i] <= x })
if i < len(a) && a[i] == x {
fmt.Printf("found %d at index %d in %v\n", x, i, a)
} else {
fmt.Printf("%d not found in %v\n", x, a)
}
Вывод:
found 6 at index 7 in [55 45 36 28 21 15 10 6 3 1]
func SearchFloat64s
func SearchFloat64s(a []float64, x float64) int
SearchFloat64s ищет x в отсортированном срезе float64 и возвращает индекс, как указано в Search. Возвращаемое значение — индекс для вставки x, если x отсутствует (он может быть len(a)). Срез должен быть отсортирован по возрастанию.
Пример
Этот пример демонстрирует поиск float64 в отсортированном списке по возрастанию.
Код:
a := []float64{1.0, 2.0, 3.3, 4.6, 6.1, 7.2, 8.0}
x := 2.0
i := sort.SearchFloat64s(a, x)
fmt.Printf("found %g at index %d in %v\n", x, i, a)
x = 0.5
i = sort.SearchFloat64s(a, x)
fmt.Printf("%g not found, can be inserted at index %d in %v\n", x, i, a)
Вывод:
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
func SearchInts(a []int, x int) int
SearchInts ищет x в отсортированном срезе целых чисел и возвращает индекс, как указано в Search. Возвращаемое значение — индекс для вставки x, если x отсутствует (он может быть len(a)). Срез должен быть отсортирован по возрастанию.
Пример
Этот пример демонстрирует поиск int в отсортированном списке по возрастанию.
Код:
a := []int{1, 2, 3, 4, 6, 7, 8}
x := 2
i := sort.SearchInts(a, x)
fmt.Printf("found %d at index %d in %v\n", x, i, a)
x = 5
i = sort.SearchInts(a, x)
fmt.Printf("%d not found, can be inserted at index %d in %v\n", x, i, a)
Вывод:
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
func SearchStrings(a []string, x string) int
SearchStrings ищет x в отсортированном срезе строк и возвращает индекс, как указано в Search. Возвращаемое значение — индекс для вставки x, если x отсутствует (он может быть len(a)). Срез должен быть отсортирован по возрастанию.
func Slice 1.8
func Slice(x any, less func(i, j int) bool)
Slice сортирует срез x с использованием предоставленной функции less. Возникает паника, если x не является срезом.
Сортировка не гарантируется как стабильная: равные элементы могут быть переставлены в обратном порядке по сравнению с исходным. Для стабильной сортировки используйте SliceStable.
Функция less должна удовлетворять тем же требованиям, что и метод Less типа Interface.
Примечание: во многих ситуациях новая функция slices.SortFunc более удобна в использовании и выполняется быстрее.
Пример
Код:
people := []struct {
Name string
Age int
}{
{"Gopher", 7},
{"Alice", 55},
{"Vera", 24},
{"Bob", 75},
}
sort.Slice(people, func(i, j int) bool { return people[i].Name < people[j].Name })
fmt.Println("By name:", people)
sort.Slice(people, func(i, j int) bool { return people[i].Age < people[j].Age })
fmt.Println("By age:", people)
Вывод:
By name: [{Alice 55} {Bob 75} {Gopher 7} {Vera 24}]
By age: [{Gopher 7} {Vera 24} {Alice 55} {Bob 75}]
func SliceIsSorted 1.8
func SliceIsSorted(x any, less func(i, j int) bool) bool
SliceIsSorted сообщает, отсортирован ли срез x в соответствии с предоставленной функцией less. Возникает паника, если x не является срезом.
Примечание: во многих ситуациях новая функция slices.IsSortedFunc более удобна в использовании и выполняется быстрее.
func SliceStable 1.8
func SliceStable(x any, less func(i, j int) bool)
SliceStable сортирует срез x, используя предоставленную функцию less, сохраняя порядок равных элементов. Возникает паника, если x не является срезом.
Функция less должна удовлетворять тем же требованиям, что и метод Less типа Interface.
Примечание: во многих ситуациях новая функция slices.SortStableFunc более удобна в использовании и выполняется быстрее.
Пример
Код:
people := []struct {
Name string
Age int
}{
{"Alice", 25},
{"Elizabeth", 75},
{"Alice", 75},
{"Bob", 75},
{"Alice", 75},
{"Bob", 25},
{"Colin", 25},
{"Elizabeth", 25},
}
// Sort by name, preserving original order
sort.SliceStable(people, func(i, j int) bool { return people[i].Name < people[j].Name })
fmt.Println("By name:", people)
// Sort by age preserving name order
sort.SliceStable(people, func(i, j int) bool { return people[i].Age < people[j].Age })
fmt.Println("By age,name:", people)
Вывод:
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
func Sort(data Interface)
Sort сортирует данные в порядке возрастания, как определено методом Less. Выполняется один вызов data.Len для определения n и O(n*log(n)) вызовов data.Less и data.Swap. Сортировка не гарантируется как стабильная.
Примечание: во многих ситуациях новая функция slices.SortFunc более удобна в использовании и выполняется быстрее.
func Stable 1.2
func Stable(data Interface)
Stable сортирует данные в порядке возрастания, как определено методом Less, сохраняя исходный порядок равных элементов.
Выполняется один вызов data.Len для определения n, O(n*log(n)) вызовов data.Less и O(n*log(n)*log(n)) вызовов data.Swap.
Примечание: во многих ситуациях новая функция slices.SortStableFunc более удобна в использовании и выполняется быстрее.
func Strings
func Strings(x []string)
Strings сортирует срез строк в порядке возрастания.
Примечание: начиная с Go 1.22, эта функция просто вызывает slices.Sort.
Пример
Код:
s := []string{"Go", "Bravo", "Gopher", "Alpha", "Grin", "Delta"}
sort.Strings(s)
fmt.Println(s)
Вывод:
[Alpha Bravo Delta Go Gopher Grin]
func StringsAreSorted
func StringsAreSorted(x []string) bool
StringsAreSorted сообщает, отсортирован ли срез x в порядке возрастания.
Примечание: начиная с Go 1.22, эта функция просто вызывает slices.IsSorted.
type Float64Slice
Float64Slice реализует Interface для []float64, сортируя в порядке возрастания, с значениями Not-a-number (NaN) перед другими значениями.
type Float64Slice []float64
func (Float64Slice) Len
func (x Float64Slice) Len() int
func (Float64Slice) Less
func (x Float64Slice) Less(i, j int) bool
Less сообщает, следует ли x[i] расположить перед x[j], как требуется интерфейсом sort. Обратите внимание, что сравнение чисел с плавающей точкой само по себе не является транзитивным отношением: оно не сообщает последовательный порядок для значений Not-a-number (NaN). Данная реализация Less помещает значения NaN перед другими, используя:
x[i] < x[j] || (math.IsNaN(x[i]) && !math.IsNaN(x[j]))
func (Float64Slice) Search
func (p Float64Slice) Search(x float64) int
Search возвращает результат применения SearchFloat64s к получателю и x.
func (Float64Slice) Sort
func (x Float64Slice) Sort()
Sort — это удобный метод: x.Sort() вызывает Sort(x).
func (Float64Slice) Swap
func (x Float64Slice) Swap(i, j int)
type IntSlice
IntSlice добавляет методы Interface к []int, сортируя по возрастанию.
type IntSlice []int
func (IntSlice) Len
func (x IntSlice) Len() int
func (IntSlice) Less
func (x IntSlice) Less(i, j int) bool
func (IntSlice) Search
func (p IntSlice) Search(x int) int
Search возвращает результат применения SearchInts к получателю и x.
func (IntSlice) Sort
func (x IntSlice) Sort()
Sort — это удобный метод: x.Sort() вызывает Sort(x).
func (IntSlice) Swap
func (x IntSlice) Swap(i, j int)
type Interface
Реализация Interface может быть отсортирована с помощью процедур в этом пакете. Методы относятся к элементам базовой коллекции по целочисленному индексу.
type Interface interface {
// Len is the number of elements in the collection.
Len() int
// 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.
Less(i, j int) bool
// Swap swaps the elements with indexes i and j.
Swap(i, j int)
} func Reverse 1.1
func Reverse(data Interface) Interface
Reverse возвращает обратный порядок для данных.
Пример
Код:
s := []int{5, 2, 6, 3, 1, 4} // unsorted
sort.Sort(sort.Reverse(sort.IntSlice(s)))
fmt.Println(s)
Вывод:
[6 5 4 3 2 1]
type StringSlice
StringSlice добавляет методы Interface к []string, сортируя в порядке возрастания.
type StringSlice []string
func (StringSlice) Len
func (x StringSlice) Len() int
func (StringSlice) Less
func (x StringSlice) Less(i, j int) bool
func (StringSlice) Search
func (p StringSlice) Search(x string) int
Search возвращает результат применения SearchStrings к получателю и x.
func (StringSlice) Sort
func (x StringSlice) Sort()
Sort — это удобный метод: x.Sort() вызывает Sort(x).
func (StringSlice) Swap
func (x StringSlice) Swap(i, j int)
© Google, Inc.
Licensed under the Creative Commons Attribution License 3.0.
http://golang.org/pkg/sort/
