Package sort

import "sort"
Overview
Index
Examples

Overview ▾

包排序提供了用于对切片和用户定义的集合进行排序的原语.

Example

[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演示了一种使用可编程排序标准对结构类型进行排序的技术.

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演示了一种在比较中使用多个字段的不同集合对结构类型进行排序的技术. 我们将" Less"功能链接在一起,每个功能都比较一个字段.

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} {r Go 100} {gri Go 100} {ken Go 200} {glenda 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)

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)

Index ▾

Package files

search.go slice.go slice_go113.go sort.go zfuncversion.go

func Float64s

func Float64s(a []float64)

Float64s按递增顺序对float64的一部分进行排序(非数字值被视为小于其他值).

Example

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

func Float64sAreSorted

func Float64sAreSorted(a []float64) bool

Float64sAreSorted测试一片float64s是否按升序排序(非数字值被视为小于其他值).

Example

true
false
false

func Ints

func Ints(a []int)

整数按升序对一片整数进行排序.

Example

[1 2 3 4 5 6]

func IntsAreSorted

func IntsAreSorted(a []int) bool

IntsAreSorted测试是否按增量顺序对一个整数切片进行排序.

Example

true
false
false

func IsSorted

func IsSorted(data Interface) bool

IsSorted报告是否对数据进行排序.

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

搜索使用二分查找来查找并返回[0,n)中f(i)为true的最小索引i,假设在[0,n)范围内,f(i)== true表示f(i + 1)==正确. 也就是说,搜索要求f对于输入范围[0,n)的某些前缀(可能为空)为false,然后对于其余部分(可能为空)为true; 搜索返回第一个真实索引. 如果没有这样的索引,则Search返回n. (请注意,"未找到"返回值不是-1,例如在strings.Index中.)搜索仅针对范围[0,n]中的i调用f(i).

搜索的常见用途是在排序的可索引数据结构(例如数组或切片)中找到值x的索引i. 在这种情况下,参数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)
}

示例(降序排列)

本示例演示搜索按降序排序的列表. 该方法与以升序搜索列表相同,但条件相反.

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在float64s的排序切片中搜索x,并返回Search指定的索引. 返回值是在x不存在的情况下插入x的索引(可能是len(a)). 切片必须按升序排序.

func SearchInts

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

SearchInts在按整数排序的切片中搜索x并返回Search指定的索引. 返回值是在x不存在的情况下插入x的索引(可能是len(a)). 切片必须按升序排序.

func SearchStrings

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

SearchStrings在已排序的字符串切片中搜索x并返回Search指定的索引. 返回值是在x不存在的情况下插入x的索引(可能是len(a)). 切片必须按升序排序.

func Slice 1.8

func Slice(slice interface{}, less func(i, j int) bool)

切片根据提供的较少功能对提供的切片进行排序.

不能保证排序是稳定的. 对于稳定的排序,请使用SliceStable.

如果提供的接口不是切片,则该函数会出现紧急情况.

Example

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(slice interface{}, less func(i, j int) bool) bool

SliceIsSorted tests whether a slice is sorted.

如果提供的接口不是切片,则该函数会出现紧急情况.

func SliceStable 1.8

func SliceStable(slice interface{}, less func(i, j int) bool)

SliceStable在给定提供的较少功能的情况下对提供的切片进行排序,同时保持相等元素的原始顺序.

如果提供的接口不是切片,则该函数会出现紧急情况.

Example

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)

排序对数据进行排序. 它对data.Len进行一次调用以确定n,然后对data.Less和data.Swap进行O(n * log(n))调用. 不能保证排序是稳定的.

func Stable 1.2

func Stable(data Interface)

稳定排序数据,同时保持相等元素的原始顺序.

它只对数据进行一次调用.Len确定n,对数据进行O(n * log(n))调用;对Less和O(n * log(n)* log(n))进行数据调用.交换.

func Strings

func Strings(a []string)

字符串按升序对字符串的一部分进行排序.

Example

[Alpha Bravo Delta Go Gopher Grin]

func StringsAreSorted

func StringsAreSorted(a []string) bool

StringsAreSorted测试字符串的切片是否按升序排序.

type Float64Slice

Float64Slice将Interface的方法附加到[] float64上,并按升序排序(非数字值被视为小于其他值).

type Float64Slice []float64

func (Float64Slice) Len

func (p Float64Slice) Len() int

func (Float64Slice) Less

func (p Float64Slice) Less(i, j int) bool

func (Float64Slice) Search

func (p Float64Slice) Search(x float64) int

搜索返回将SearchFloat64s应用于接收者和x的结果.

func (Float64Slice) Sort

func (p Float64Slice) Sort()

排序是一种方便的方法.

func (Float64Slice) Swap

func (p Float64Slice) Swap(i, j int)

type IntSlice

IntSlice将Interface的方法附加到[] int上,并按升序排序.

type IntSlice []int

func (IntSlice) Len

func (p IntSlice) Len() int

func (IntSlice) Less

func (p IntSlice) Less(i, j int) bool

func (IntSlice) Search

func (p IntSlice) Search(x int) int

搜索返回将SearchInts应用于接收者和x的结果.

func (IntSlice) Sort

func (p IntSlice) Sort()

排序是一种方便的方法.

func (IntSlice) Swap

func (p IntSlice) Swap(i, j int)

type Interface

满足sort的类型(通常是集合).可以通过此包中的例程对Interface进行排序. 这些方法要求集合的元素由整数索引枚举.

type Interface interface {
    // Len is the number of elements in the collection.
    Len() int
    // Less reports whether the element with
    // index i should sort before the element with index j.
    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

反向返回数据的反向顺序.

Example

[6 5 4 3 2 1]

type StringSlice

StringSlice将Interface的方法附加到[] string上,并按升序排序.

type StringSlice []string

func (StringSlice) Len

func (p StringSlice) Len() int

func (StringSlice) Less

func (p StringSlice) Less(i, j int) bool

func (StringSlice) Search

func (p StringSlice) Search(x string) int

搜索返回将SearchStrings应用于接收者和x的结果.

func (StringSlice) Sort

func (p StringSlice) Sort()

排序是一种方便的方法.

func (StringSlice) Swap

func (p StringSlice) Swap(i, j int)

by  ICOPY.SITE