golang sort包

最新推荐文章于 2025-06-14 18:40:22 发布
转载 最新推荐文章于 2025-06-14 18:40:22 发布 · 209 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://blog.youkuaiyun.com/chenbaoke/article/details/42340301
文章标签：

#golang

本文详细介绍了Go语言中的排序包，包括基本的排序算法实现、如何使用sort.Interface接口进行自定义排序，以及二分查找功能。此外，还展示了如何对特定数据类型进行排序，并提供了排序稳定性方面的指导。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

以下内容转载自 https://blog.youkuaiyun.com/chenbaoke/article/details/42340301

golang中也实现了排序算法的包sort包．

sort包中实现了３种基本的排序算法：插入排序．快排和堆排序．和其他语言中一样，这三种方式都是不公开的，他们只在sort包内部使用．所以用户在使用sort包进行排序时无需考虑使用那种排序方式，sort.Interface定义的三个方法：获取数据集合长度的Len()方法、比较两个元素大小的Less()方法和交换两个元素位置的Swap()方法，就可以顺利对数据集合进行排序。sort包会根据实际数据自动选择高效的排序算法。

 

 

type Interface

type Interface interface {

    Len() int    // Len 为集合内元素的总数
  
    Less(i, j int) bool　//如果index为i的元素小于index为j的元素，则返回true，否则返回false

    Swap(i, j int)  // Swap 交换索引为 i 和 j 的元素
}

 

任何实现了 sort.Interface 的类型（一般为集合），均可使用该包中的方法进行排序。这些方法要求集合内列出元素的索引为整数。


func Float64s(a []float64)     //Float64s将类型为float64的slice a以升序方式进行排序
func Float64sAreSorted(a []float64) bool　　//判定是否已经进行排序func Ints(a []int)

func Ints(a []int)                       //Ints 以升序排列 int 切片。
func IntsAreSorted(a []int) bool　　　  //IntsAreSorted 判断 int 切片是否已经按升序排列。
func IsSorted(data Interface) bool    IsSorted 判断数据是否已经排序。包括各种可sort的数据类型的判断．

func Strings(a []string)//Strings 以升序排列 string 切片。
func StringsAreSorted(a []string) bool//StringsAreSorted 判断 string 切片是否已经按升序排列。

 

 

  1. package main

  2.  

  3. import (

  4. "fmt"

  5. "sort"

  6. )

  7.  

  8. //定义interface{},并实现sort.Interface接口的三个方法

  9. type IntSlice []int

  10.  

  11. func (c IntSlice) Len() int {

  12. return len(c)

  13. }

  14. func (c IntSlice) Swap(i, j int) {

  15. c[i], c[j] = c[j], c[i]

  16. }

  17. func (c IntSlice) Less(i, j int) bool {

  18. return c[i] < c[j]

  19. }

  20.  

  21. func main() {

  22. a := IntSlice{1, 3, 5, 7, 2}

  23. b := []float64{1.1, 2.3, 5.3, 3.4}

  24. c := []int{1, 3, 5, 4, 2}

  25. fmt.Println(sort.IsSorted(a)) //false

  26. if !sort.IsSorted(a) {

  27. sort.Sort(a)

  28. }

  29.  

  30. if !sort.Float64sAreSorted(b) {

  31. sort.Float64s(b)

  32. }

  33. if !sort.IntsAreSorted(c) {

  34. sort.Ints(c)

  35. }

  36. fmt.Println(a)//[1 2 3 5 7]

  37. fmt.Println(b)//[1.1 2.3 3.4 5.3]

  38. fmt.Println(c)// [1 2 3 4 5]

  39. }

  40.  

 

 

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

search使用二分法进行查找，Search()方法回使用“二分查找”算法来搜索某指定切片[0:n]，并返回能够使f(i)=true的最小的i（0<=i<n）值，并且会假定，如果f(i)=true，则f(i+1)=true，即对于切片[0:n]，i之前的切片元素会使f()函数返回false，i及i之后的元素会使f()函数返回true。但是，当在切片中无法找到时f(i)=true的i时（此时切片元素都不能使f()函数返回true），Search()方法会返回n（而不是返回-1）。

Search 常用于在一个已排序的，可索引的数据结构中寻找索引为 i 的值 x，例如数组或切片。这种情况下，实参 f，一般是一个闭包，会捕获所要搜索的值，以及索引并排序该数据结构的方式。

为了查找某个值，而不是某一范围的值时，如果slice以升序排序，则　f func中应该使用＞＝,如果slice以降序排序，则应该使用<=. 例子如下：package main
 

 

  1. package main

  2.  

  3. import (

  4. "fmt"

  5. "sort"

  6. )

  7.  

  8. func main() {

  9. a := []int{1, 2, 3, 4, 5}

  10. b := sort.Search(len(a), func(i int) bool { return a[i] >= 30 })

  11. fmt.Println(b)　　　　　　　//5，查找不到，返回a slice的长度５，而不是-1

  12. c := sort.Search(len(a), func(i int) bool { return a[i] <= 3 })

  13. fmt.Println(c) //0，利用二分法进行查找，返回符合条件的最左边数值的index，即为０

  14. d := sort.Search(len(a), func(i int) bool { return a[i] == 3 })

  15. fmt.Println(d) //2　　　

  16. }

 

官网上面有趣的例子：

 

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 在float64s切片中搜索x并返回索引如Search函数所述. 返回可以插入x值的索引位置，如果x不存在，返回数组a的长度切片必须以升序排列
func SearchInts(a []int, x int) int  //SearchInts 在ints切片中搜索x并返回索引如Search函数所述. 返回可以插入x值的索引位置，如果x不存在，返回数组a的长度切片必须以升序排列
func SearchStrings(a []string, x string) int//SearchFloat64s 在strings切片中搜索x并返回索引如Search函数所述. 返回可以插入x值的索引位置，如果x不存在，返回数组a的长度切片必须以升序排列

其中需要注意的是，以上三种search查找方法，其对应的slice必须按照升序进行排序，否则会出现奇怪的结果．

 

 

  1. package main

  2.  

  3. import (

  4. "fmt"

  5. "sort"

  6. )

  7.  

  8. func main() {

  9. a := []string{"a", "c"}

  10. i := sort.SearchStrings(a, "b")

  11. fmt.Println(i) //1

  12. b := []string{"a", "b", "c", "d"}

  13. i = sort.SearchStrings(b, "b")

  14. fmt.Println(i) //1

  15. c := []string{"d", "c"}

  16. i = sort.SearchStrings(c, "b")

  17. fmt.Println(i) //0

  18. d := []string{"c", "d", "b"}

  19. i = sort.SearchStrings(d, "b")

  20. fmt.Println(i) //0，由于d不是以升序方式排列，所以出现奇怪的结果，这可以根据SearchStrings的定义进行解释．见下方．

  21. }

  22. func SearchStrings(a []string, x string) int {

  23. return Search(len(a), func(i int) bool { return a[i] >= x })

  24. }

由此可见，为了精确查找，必须对[]string　以升序方式进行排序．

 

 

func Sort(data Interface)//Sort 对 data 进行排序。它调用一次 data.Len 来决定排序的长度 n，调用 data.Less 和 data.Swap 的开销为O(n*log(n))。此排序为不稳定排序。他根据不同形式决定使用不同的排序方式（插入排序，堆排序，快排）

 

func Stable(data Interface)Stable对data进行排序，不过排序过程中，如果data中存在相等的元素，则他们原来的顺序不会改变，即如果有两个相等元素num,他们的初始index分别为i和j，并且i<j，则利用Stable对data进行排序后，i依然小于ｊ．直接利用sort进行排序则不能够保证这一点．

 

golang自身实现的interface有三种，Float64Slice，IntSlice，StringSlice，具体如下所示：

type Float64Slice

 

type Float64Slice []float64

Float64Slice 针对 []float6 实现接口的方法，以升序排列。

 

 

 

  1. func (p Float64Slice) Len() int　　　　//求长度

  2. func (p Float64Slice) Less(i, j int) bool　//比大小

  3. func (p Float64Slice) Search(x float64) int　//查找

  4. func (p Float64Slice) Sort()　　　　　　//排序

  5. func (p Float64Slice) Swap(i, j int)　　　//交换位置

 

 


type IntSlice

 

type IntSlice []int

 

IntSlice 针对 []int 实现接口的方法，以升序排列。

 

  1. func (p IntSlice) Len() int

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

  3. func (p IntSlice) Search(x int) int

  4. func (p IntSlice) Sort()

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

 


type StringSlice

 

type StringSlice []string

 

StringSlice 针对 []string 实现接口的方法，以升序排列。

 

  1. func (p StringSlice) Len() int

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

  3. func (p StringSlice) Search(x string) int

  4. func (p StringSlice) Sort()

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



func Reverse(data Interface) Interface

 

func Reverse(data Interface) Interface

Reverse实现对data的逆序排列

 

 

 

  1. package main

  2.  

  3. import (

  4. "fmt"

  5. "sort"

  6. )

  7.  

  8. func main() {

  9. a := []int{1, 2, 5, 3, 4}

  10. fmt.Println(a) // [1 2 5 3 4]

  11. sort.Sort(sort.Reverse(sort.IntSlice(a)))

  12. fmt.Println(a) // [5 4 3 2 1]

  13. }

Go语言学习笔记—golang标准库sort包
qq_39280718的博客
07-14 518
sort包提供了排序切片和用户自定义数据集以及相关功能的函数。
Golang sort包Search函数源码分析
luyuan492的博客
12-01 2765
首先放今天的力扣打卡题。 在第一次做的过程中，我忽略了“升序排列”这个条件，没有使用二分。 由于是最近才刚开始学golang，所以很有兴趣的在这道题里使用了go的大杀器——goroutine。思路就是使用两个goroutine，一个从头到尾遍历数组，找出开始位置，一个倒序遍历数组，找到结束位置。 代码如下： func searchRange(nums []int, target int) []int { //使用WaitGroup控制goroutine var wg sync.WaitGroup /
golang中sort包用法
weixin_34242819的博客
01-02 599
golang中也实现了排序算法的包sort包． sort包中实现了３种基本的排序算法：插入排序．快排和堆排序．和其他语言中一样，这三种方式都是不公开的，他们只在sort包内部使用．所以用户在使用sort包进行排序时无需考虑使用那种排序方式，sort.Interface定义的三个方法：获取数据集合长度的Len()方法、比较两个元素大小的Less()方法和交换两个元素位置的Swap()方法，...
21、go语言标准库、sort
最新发布
m0_63008237的博客
06-14 172
21、go语言标准库、sort
GoLang之标准库sort包
weixin_52690231的博客
04-18 3370
GoLang之标准库sort包
Golang sort 包
green_water995400524的博客
06-12 463
Golang sort 包 sort 是排序 查找包 排序 go 排序一般默认都是 升序 package main import ( "fmt" "sort" ) func main() { var num = []int{2,5,3,8,9} sort.Ints(num) //升序 fmt.Println(num) sort.Sort(sort.Reverse(sort.IntSlice(num))) //降序 fmt.Println(num) } 切片排序 数组排序，是以 sort.
Golang之Sort包
slphahaha的博客
05-20 948
​Go语言是一门非常简单优雅的语言，其源码更是其风格标杆。看源码，不仅能学习Go的设计哲学，了解如何调用库函数，同时帮助我们写出更优雅的go代码。 Go源码位于GOROOT目录下的src中。 本文学习1.14.1版本源码库的sort包。该包对外提供的主要功能是排序和搜索。其核心的函数分别是：sort.Sort()与sort.Search()。 1. sort.Sort() 函数定义如下 func Sort(data Interface) { n := data.Len() quickSo
golang内置包里面的sort.Slice 切片排序函数使用示例
Tekin 是深耕技术 20 年的全栈实战派专家，精通 Go/Python/Java 等多语言开发。博客专注技术原理与实战结合，深度解析 Python 高阶编程、Go 语言架构、数据库优化等硬核内容。涵盖并发编程、机器学习、云原生等前沿领域，通过真实案例拆
05-08 1628
var s1 = []int{133,144,21,69,83,37,56,38,68,123,23,89,170,8,76,120} // 这个就是要排序的int切片。参数说明 这个函数有2个参数， 第一个是你要进行排序的slice切片，地个要传递一个函数，这个函数就是你要对你的数据进行怎么样的排序。go语言里面用的最多的数据类型应该是切片Slice了， 今天就给大家介绍这个go内置包里面的切片排序函数的使用方法。怎么样，是不是很简单， 其他2个函数用法可参考后面的源码使用。
GoLang sort.Slice重写比较函数分析
Mr_scott_j的博客
03-19 837
先看一个sort.Slice重写比较函数的例子 sort.Slice(intervals, func(i, j int) bool { // 闭包 return intervals[i][0] < intervals[j][0] }) 注意到上面的Slice的第二个比较函数就用到了闭包，引用了intervals，要注意这里的intervals会通过后面的less函数间接操作。我们再来看一下Slice的源码部分，any是type any = interface{} 空接口eface func Sl
golang 中的sort 包
01-08 266
golang 中的sort 包
golang sort包介绍
biello的博客
02-21 366
sort包提供了对集合排序和查找的基础函数集，主要有两部分：sort和search 一、sort     1. sort对外提供了对集合排序的方法，排序算法的实现是快速排序、堆排序和插入排序的组合，最简单常见的方法是： func Ints(a []int) //对[]int排序，快排、堆排序和插入排序组合使用，不稳定 func Float64s(a []float64) ...
golang中sort包实现与应用
Mrs_len的博客
01-04 3135
1、简介sort包中实现了３种基本的排序算法：插入排序．快排和堆排序．和其他语言中一样，这三种方式都是不公开的，他们只在sort包内部使用．所以用户在使用sort包进行排序时无需考虑使用那种排序方式，sort.Interface定义的三个方法：获取数据集合长度的Len()方法、比较两个元素大小的Less()方法和交换两个元素位置的Swap()方法，就可以顺利对数据集合进行排序。sort包会根据实际数
Golang切片排序
风火燎原、
12-02 751
golang的sort工具包，提供基本类型int、float64和string的排序，使用方法如下： import ( "fmt" "sort" ) func main() { arrInts := []int{1, 3, 11, 5, 14} arrFloats := []float64{1.8, 1.1, 4.2, 2.3} arrStrs := []string{"ac", "bc", "ab"} //升序 sort.Ints(arrInts) sort.Float64s(ar
Golang sort包排序（详细全集）
热门推荐
名狱的博客
12-05 1万+
文章目录一、整型倒序二、浮点型三、字符串型四、真的使用的是快速排序算法吗？五、稳定性六、结构体类型排序
golang标准库中的sort包
我都不会的博客
03-05 229
package main import ( "fmt" "sort" ) func main() { // https://pkg.go.dev/sort#Ints s := []int{2, 4, 1, 3} // 排序正序 sort.Ints(s) fmt.Printf("s: %v\n", s) // s: [1 2 3 4] f := []float64{1.1, 4.4, 5.5, 3.3, 2.2} sort.Float64s(f) fmt.Printf("f: %v
Go语言自学系列 | golang标准库中的sort包
COCO_gsta的博客
06-13 544
视频来源：B站《golang入门到项目实战 [2021最新Go语言教程，没有废话，纯干货！持续更新中...]》一边学习一边整理老师的课程内容及试验笔记，并与大家分享，侵权即删，谢谢支持！附上汇总贴：Go语言自学系列 | 汇总_COCOgsta的博客-优快云博客_go语言自学sort包提供了排序切片和用户自定义数据集以及相关功能的函数。sort包主要针对[]int、[]float64、[]string、以及其他自定义切片的排序。 函数 接口 type interface 实例 运行结果
golang sort包学习
boshuzhang的专栏
08-26 233
//sort //sort包提供了 //排序切片 //和 //用户自定义数据集的函数 type Interface interface{ //Len 方法返回集合中元素个数 Len()int //Less方法报告索引i的元素是否比索引j的元素小 Less(i,j int)bool //Swap 方法交换索引i 和 j的两个元素 Swap(i,j int) } //满足接口...
【golang】看一看官方包sort
huangfengnt的博客
07-06 591
golang官方包之sort
golang sort
07-27
在Golang中，可以使用sort包来对切片进行排序。sort包提供了多种排序算法，包括快速排序、堆排序和插入排序等。 首先，你需要导入sort包： ```go import "sort" ``` 然后，你可以使用sort.Slice函数对切片进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值