go语言的魔幻旅程22-sort包

最新推荐文章于 2023-02-13 16:09:26 发布
最新推荐文章于 2023-02-13 16:09:26 发布
阅读量172 收藏 1
点赞数
分类专栏： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47978762/article/details/116647388
版权

生存还是毁灭，这是个问题

最近无意中刷到华为创始人任正非的一则访谈视频，视频中任老板首先是针对某位房产大佬的小目标进行了一番批判，然后话锋一转，批判在金钱至上的社会中要能忍得住浮躁，不为眼前产生的泡沫所诱惑，任老板的话可谓一针见血。在经过几十年的发展之后，绝大部分的人都摆脱了过去吃不饱，睡不暖的穷苦日子，然则要想满足额外的物质享受，光靠工资这种单一的收入来源显然不能满足所需，在此情形之下，币圈一日，人间一年的神话不断上演，每个人都想趁机捞一笔，但是有赢家必定有输家，最大的赢家无非是交易所，毕竟人家不是做慈善的，不过还是像任老板所说的那样，越是穷苦，越是需要干坐冷板凳，踏踏实实的奋斗，不一头扎入泡沫中。

go语言的sort包

go语言的sort包的作用是对元素进行按照一定的规则对元素进行相关的排序，下面主要针对sort包中的函数和方法展开讲解。

package main

/*********************************************************************/
/**************** golang中sort包相关API讲解 ************************/
/*******************************************************************/

/*
func Float64s(x []float64)
func Float64sAreSorted(x []float64) bool
func Ints(x []int)
func IntsAreSorted(x []int) bool
func IsSorted(data Interface) bool
func Search(n int, f func(int) bool) int
func SearchFloat64s(a []float64, x float64) int
func SearchInts(a []int, x int) int
func SearchStrings(a []string, x string) int
func Slice(x interface{}, less func(i, j int) bool)
func SliceIsSorted(x interface{}, less func(i, j int) bool) bool
func SliceStable(x interface{}, less func(i, j int) bool)
func Sort(data Interface)
func Stable(data Interface)
func Strings(x []string)
func StringsAreSorted(x []string) bool
type Float64Slice
	func (x Float64Slice) Len() int
	func (x Float64Slice) Less(i, j int) bool
	func (p Float64Slice) Search(x float64) int
	func (x Float64Slice) Sort()
	func (x Float64Slice) Swap(i, j int)
type IntSlice
	func (x IntSlice) Len() int
	func (x IntSlice) Less(i, j int) bool
	func (p IntSlice) Search(x int) int
	func (x IntSlice) Sort()
	func (x IntSlice) Swap(i, j int)
type Interface
	func Reverse(data Interface) Interface
type StringSlice
	func (x StringSlice) Len() int
	func (x StringSlice) Less(i, j int) bool
	func (p StringSlice) Search(x string) int
	func (x StringSlice) Sort()
	func (x StringSlice) Swap(i, j int)
*/


func main() {

	/**
	*Float64s按递增顺序对float64s的一部分进行排序。 Not-a-number(NaN)值先于其他值排序。
	*func Float64s(x []float64)
	*/

	/*
	s := []float64{5.2, -1.3, 0.7, -3.8, 2.6}
	sort.Float64s(s)
	fmt.Println(s)

	s = []float64{math.Inf(1), math.NaN(), math.Inf(-1), 0.0}
	sort.Float64s(s)
	fmt.Println(s)
	*/

	/**
	*Float64sAreSorted报告切片x是否以递增的顺序排序，其中not-a-number(NaN)值位于任何其他值之前。
	*func Float64sAreSorted(x []float64) bool
	*/

	/*
	s := []float64{0.7, 1.3, 2.6, 3.8, 5.2}
	fmt.Println(sort.Float64sAreSorted(s))

	s = []float64{5.2, 3.8, 2.6, 1.3, 0.7}
	fmt.Println(sort.Float64sAreSorted(s))

	s = []float64{5.2, 1.3, 0.7, 3.8, 2.6}
	fmt.Println(sort.Float64sAreSorted(s))
	*/


	/**
	*整数按升序对一片整数进行排序
	*func Ints(x []int)
	*/

	/*
	s := []int{5, 2, 6, 3, 1, 4}
	sort.Ints(s)
	fmt.Println(s)
	*/

	/**
	*IntsAreSorted报告切片x是否按升序排序。
	*func IntsAreSorted(x []int) bool
	*/

	/*
	s := []int{1, 2, 3, 4, 5, 6}
	fmt.Println(sort.IntsAreSorted(s))

	s = []int{6, 5, 4, 3, 2, 1}
	fmt.Println(sort.IntsAreSorted(s))

	s = []int{3, 2, 4, 1, 5}
	fmt.Println(sort.IntsAreSorted(s))
	*/

	/**
	*IntsAreSorted报告切片x是否按升序排序。
	*func IsSorted(data Interface) bool
	*/

	/*
	type IntSlice []int
	a := IntSlice{1, 3, 5, 7, 2}
	fmt.Println(sort.IsSorted(a))
	*/

	/**
	*search使用二分法进行查找
	*func Search(n int, f func(int) bool) int
	*/

	/*
	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)
	}
	*/

	/**
	*SearchFloat64s 在float64s切片中搜索x并返回索引如Search函数所述.
	*返回可以插入x值的索引位置，如果x不存在，返回值是x应该插入a的位置
	*（以保证a的递增顺序
	*func SearchFloat64s(a []float64, x float64) int
	*/

	/*
	s := []float64{5.2, -1.3, 0.7, -3.8, 2.6}
	index := sort.SearchFloat64s(s, 2)
	fmt.Println(index)
	*/

	/**
	*返回x在a中应该存在的位置，无论a中是否存在a中在递增顺序的a中搜索x，返回x的索引。
	*如果查找不到，返回值是x应该插入a的位置（以保证a的递增顺序），返回值可以是len(a)
	*func SearchInts(a []int, x int) int
	*/

	/*
	s := []int{5, 2, 6, 3, 1, 4}
	index := sort.SearchInts(s, 5)
	fmt.Println(index)
	*/

	/**
	*返回x在a中应该存在的位置，无论a中是否存在a中, 在递增顺序的a中搜索x，返回x的索引。
	*如果查找不到，返回值是x应该插入a的位置（以保证a的递增顺序），返回值可以是len(a)
	*func SearchStrings(a []string, x string) int
	*/

	/*
	s := []string{"Go", "Bravo", "Gopher", "Alpha", "Grin", "Delta"}
	index := sort.SearchStrings(s, "Hello")
	fmt.Println(index)
	*/

	/**
	*切片根据给定的less函数对切片x进行排序。如果x不是切片，它会发生panic,
	*不能保证排序是稳定的：相等的元素可能与其原始顺序相反。对于稳定的排序，
	*请使用SliceStable
	*func Slice(x interface{}, less func(i, j int) bool)
	*/

	/*
	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)
	*/


	/**
	*SliceIsSorted报告切片x是否根据提供的less函数排序。如果x不是切片，它会发生panic
	*func SliceIsSorted(x interface{}, less func(i, j int) bool) bool
	*/

	/*
	people := []struct {
		Name string
		Age  int
	}{
		{"Alice", 25},
		{"Elizabeth", 75},
		{"Alice", 75},
		{"Bob", 75},
		{"Alice", 75},
		{"Bob", 25},
		{"Colin", 25},
		{"Elizabeth", 25},
	}

	sort.SliceIsSorted(people, func(i, j int) bool {
		return people[i].Name < people[j].Name})
	fmt.Println("By name:", people)

	sort.SliceIsSorted(people, func(i, j int) bool {
		return people[i].Age < people[j].Age })
	fmt.Println("By age,name:", people)
	*/


	/**
	*SliceStable使用所提供的less函数对slice x进行排序，以其原始顺序保留相等的元素。
	*如果x不是切片，它会发生panic。
	*func SliceStable(x interface{}, less func(i, j int) bool)
	*/

	/*
	people := []struct {
		Name string
		Age  int
	}{
		{"Alice", 25},
		{"Elizabeth", 75},
		{"Alice", 75},
		{"Bob", 75},
		{"Alice", 75},
		{"Bob", 25},
		{"Colin", 25},
		{"Elizabeth", 25},
	}

	sort.SliceStable(people, func(i, j int) bool {
		return people[i].Name < people[j].Name })
	fmt.Println("By name:", people)

	sort.SliceStable(people, func(i, j int) bool {
		return people[i].Age < people[j].Age })
	fmt.Println("By age,name:", people)
	*/


	/**
	*排序对数据进行排序。它对data.Len进行一次调用，以确定对data的n和O（n * log（n）调用。
	*Less和data.Swap。不能保证排序是稳定的。
	*func Sort(data Interface)
	*/

	/*
	s := []string{"Go", "Bravo", "Gopher", "Alpha", "Grin", "Delta"}
	sort.Sort(sort.StringSlice(s))
	fmt.Println(s)
	*/

	/**
	*排序对数据进行排序。它对data.Len进行一次调用，以确定对data的n和O（n * log（n）调用。
	*func Stable(data Interface)
	*/

	/*
	type People struct {
		Name string
		Age  int
	}

	type Peoples []People

	peoples := Peoples{
		{"Gopher", 7},
		{"Alice", 55},
		{"Vera", 24},
		{"Bob", 75},
	}

	sort.Stable(peoples)
	fmt.Println(peoples)
	*/

	/**
	*字符串按升序对字符串的一部分进行排序。
	*func Strings(x []string)
	*/

	/*
	s := []string{"Go", "Bravo", "Gopher", "Alpha", "Grin", "Delta"}
	sort.Strings(s)
	fmt.Println(s)
	*/

	/**
	*检查是否已排序为递增顺序
	*func StringsAreSorted(x []string) bool
	*/

	/*
	s := []string{"Go", "Bravo", "Gopher", "Alpha", "Grin", "Delta"}
	fmt.Println(sort.StringsAreSorted(s))
	*/

	/*********************************************************************/
	/**************** Float64Slice中相关方法讲解 ************************/
	/*******************************************************************/

	/**
	*求FloatSlice的数据类型的长度
	*func (x Float64Slice) Len() int
	*/

	/*
	var x sort.Float64Slice
	x = []float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.NaN(), math.NaN(), 
        math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8}
	fmt.Println(x.Len())
	*/

	/**
	*比较i,j位置两个数的大小
	*func (x Float64Slice) Less(i, j int) bool
	*/

	/*
	var x sort.Float64Slice
	x = []float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.NaN(), math.NaN(), 
        math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8}
	fmt.Println(x.Less(0, 1))
	*/


	/**
	*查找指定元素的位置
	*func (p Float64Slice) Search(x float64) int
	*/

	/*
	var x sort.Float64Slice
	x = []float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.NaN(), math.NaN(), 
        math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8}
	fmt.Println(x.Search(59.0))
	*/


	/**
	*针对Float64Slice进行排序
	*func (x Float64Slice) Sort()
	*/

	/*
	var x sort.Float64Slice
	x = []float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.NaN(), math.NaN(), 
        math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8}
	x.Sort()
	fmt.Println(x)
	*/

	/**
	*针对指定位置的元素进行交换
	*func (x Float64Slice) Swap(i, j int)
	*/

	/*
	var x sort.Float64Slice
	x = []float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.NaN(), math.NaN(), 
        math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8}
	x.Swap(0, 1)
	fmt.Println(x)
	*/

	/*********************************************************************/
	/**************** IntSlice中相关方法讲解 *****************************/
	/********************************************************************/

	/**
	*求IntSlice类型的长度
	*func (x IntSlice) Len() int
	*/

	/*
	var x sort.IntSlice
	x = []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
	fmt.Println(x.Len())
	*/

	/**
	*
	*func (x IntSlice) Less(i, j int) bool
	*/

	/*
	var x sort.IntSlice
	x = []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
	fmt.Println(x.Less(1, 2))
	*/

	/**
	*根据索引查找指定的元素
	*func (p IntSlice) Search(x int) int
	*/

	/*
	var x sort.IntSlice
	x = []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
	fmt.Println(x.Search(1))
	*/


	/**
	*针对ｘ进行排序
	*func (x IntSlice) Sort()
	*/

	/*
	var x sort.IntSlice
	x = []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
	x.Sort()
	fmt.Println(x)
	*/

	/**
	*交换指定元素的位置
	*func (x IntSlice) Swap(i, j int)
	*/

	/*
	var x sort.IntSlice
	x = []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
	x.Swap(0, 1)
	fmt.Println(x)
	*/

	/*********************************************************************/
	/**************** Interface中相关方法讲解 ***************************/
	/*******************************************************************/

	/**
	*针对元素进行逆序排列
	*func Reverse(data Interface) Interface
	*/

	/*
	var x sort.IntSlice
	x = []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
	sort.Reverse(x)
	fmt.Println(x)
	*/


	/*********************************************************************/
	/**************** StringSlice中相关方法讲解 **************************/
	/********************************************************************/

	/**
	*求StringSlice类型的长度
	*func (x StringSlice) Len() int
	*/

	/*
	var x sort.StringSlice
	x = []string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}
	fmt.Println(x.Len())
	*/

	/**
	*判断i索引的数据小于j索引的数据返回true
	*func (x StringSlice) Less(i, j int) bool
	*/

	/*
	var x sort.StringSlice
	x = []string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}
	fmt.Println(x.Less(0, 1))
	*/

	/**
	*查找x的位置
	*func (p StringSlice) Search(x string) int
	*/

	/*
	var x sort.StringSlice
	x = []string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}
	fmt.Println(x.Search("hello"))
	*/


	/**
	*针对StringSlice进行排序
	*func (x StringSlice) Sort()
	*/

	/*
	var x sort.StringSlice
	x = []string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}
	x.Sort()
	fmt.Println(x)
	*/


	/**
	*交换指定索引位置的元素
	*func (x StringSlice) Swap(i, j int)
	*/

	/*
	var x sort.StringSlice
	x = []string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}
	x.Swap(0, 1)
	fmt.Println(x)
	*/
}

小结

sort部分的内容相对而言还是比较少的，但是少不代表不重要，在某些日常开发的场景中我们总会遇到需要进行排序的情况，所以sort包的内容还是务必需要掌握的。

饱腹百科
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
go-libav:ffmpeg库的Go语言绑定
05-10
为什么我知道ffmpeg的其他Go语言绑定。 我之所以决定构建go-libav是因为我想拥有： 一种更加面向对象的编程方法。 一种更类似于Go的错误处理方法。 垃圾收集更容易。安装首先，在系统上安装ffmpeg 3.x库。 如果需要...
Go语言快速排序&TDD
weixin_43847600的博客
09-26 231
Go语言快速排序&TDD 单元测试 新建一个名为Quicksort的包，在该包下进行TDD。首先编写一个单元测试文件。 testing 提供对 Go 包的自动化测试的支持。通过 go test 命令，能够自动执行如下形式的任何函数： func TestXxx(*testing.T) 需要注意的是，测试文件名必须以xxx_test.go命名，并且测试文件中的方法必须是Test[^a-z]开头。执行单元测试的时候，只需执行go test命令即可。 该文件命名为quicksort_test.go，代码如
Go入门：sort包
林钟一的博客
02-07 2229
切片是Go语言中引入的用于在大多数场合替代数组的语法元素。切片是长度可变的同类型元素序列，它不支持存储不同类型的元素。有序列的地方就有排序的需求。在各种排序算法都已经成熟的今天，我们完全可以针对特定元素类型的切片手写排序函数/方法，但多数情况下不推荐这么做，因为Go标准库内置了sort包可以很好地帮助我们实现原生类型元素切片以及自定义类型元素切片的排序任务。Go的sort包用来排序，二分查找等操作。
Go 排序包 sort
羽的博客
02-13 464
基本实现了插入排序，归并排序，堆排序和快速排序。当然这四种排序方法是不分开的，它们是在sort包的内部被使用。所以使用时，不用考虑使用那种排序方法。sort会自动选择合适的排序方法保证高效性。
简单解决go出现大量 undefined
hightower的博客
11-22 3648
go程序运行出现大量undefined，多文件加载问题
go排序sort包详解
General_zy的博客
06-01 443
sort包提供了排序切片和用户自定义数据集的函数。
quick-sort:TypeScript QuickSort实现
03-19
import * as quickSort from 'quick-sort' ; const unsortedArray = [ 15 , 13 , 1 , 22 ] ; const sortedArray = quickSort . sort ( unsortedArray ) ; // sortedArray === [1, 13, 15, 22] 测验 yarn yarn test
嵌入式操作系统--魔幻盒子
06-04
一 任务 以VM ware虚拟机软件和Ubuntu操作系统为平台，使用shell脚本编写程序，用ASCII码字符设计一个长、宽可变的四边形。要求使用linux shell编写程序脚本（Bash风格），并提供友好的的交互界面 ...
Unity粒子特效系列-魔幻风格特效包
08-02
10个魔幻风格的粒子特效，内含运行效果视频。 Unity版本2020.3.x系列当前可运行 更多内容：https://zhima.blog.csdn.net/
Go-MISPFeedGenerator:PyMISP-feedgenerator的Golang实现
03-25
Go-MispFeedGenerator 生成没有MISP实例的MISP提要！ Go-MispFeedGenerator又名Go-MFG1000，是一个提供创建事件，添加属性和生成所需的feed文件所需的所有功能的库。 任何MISP实例都可以使用生成的文件。 通过手动...
golang run时报undefined错误【已解决】
JavaPub
07-25 3245
golang error
Golang sort排序
记事本
01-21 1043
在程序开发中，不可避免的需要给数据集进行排序，如果在语言级别不提供支持的话，我们则需要自己写算法进行数据的处理，麻烦还不一定高效。 幸好Golang在标准包中，官方有提供sort包中Sort()函数提供排序功能。并且天然支持[]int，[]float64，[]string切片的排序查找功能，并且也能够实现对自定义类型集合的排序。 下面我们先来看下golang中Sort函数的结构是什么样的。 func Sort(data Interface) { n := data.Len() quickSort(dat
golang struct数组排序_go语言中排序sort的使用方法示例
weixin_39733146的博客
12-19 594
前言sort包中实现了３种基本的排序算法：插入排序．快排和堆排序．和其他语言中一样，这三种方式都是不公开的，他们只在sort包内部使用．所以用户在使用sort包进行排序时无需考虑使用那种排序方式，sort.Interface定义的三个方法：获取数据集合长度的Len()方法、比较两个元素大小的Less()方法和交换两个元素位置的Swap()方法，就可以顺利对数据集合进行排序。sort包会根据实际数据...
golang: 使用 sort 来排序
热门推荐
weixin_41918841的博客
09-29 3万+
golang sort package: https://golang.org/src/sort sort 操作的对象通常是一个 slice，需要满足三个基本的接口，并且能够使用整数来索引 // A type, typically a collection, that satisfies sort.Interface can be // sorted by the routines in ...
Go语言sort包排序
敦煌的驼铃_Blog
03-04 2703
Go语言sort包排序 1,说明 本文主要总结go语言sort包排序的基本用法，并不实现底层排序算法。 本着不要重复造轮子的思想，工程开发中为了提高效率肯定是用sort包进行相关排序。 这里总结下基础用法，当作以后开发的笔记。 2,sort包排序三要素排序 1，简介： sort包的底层实现是多种排序的算法，例如快排，插入等等。调用时并不公开，也无需定义用那种算法。 sort包内部会根据实际情况，自动选择最高效的排序算法。 2，实现： 1，实现原理
一文搞懂Go语言中的切片排序
TonyBai
11-26 7527
切片是Go语言中引入的用于在大多数场合替代数组的语法元素。切片是长度可变的同类型元素序列，它不支持存储不同类型的元素，当然如果你非用sl := []interface{}{"he...
Golang sort包排序（详细全集）
名狱的博客
12-05 1万+
文章目录一、整型倒序二、浮点型三、字符串型四、真的使用的是快速排序算法吗？五、稳定性六、结构体类型排序
go编译错误及解决方式
迷惘宅猪的专栏
01-29 1万+
常见错误解决： 1.import cycle not allowed 原因：由于循环导入包 解决方案：避免循环导入包 2…..\go-sql-driver\mysql\connection_go18.go:42: undefined: driver.TxOptions 原因：go的版本不对，connection_go18.go使用go1.8版本进行编译的，而本机的go版本是1.8beta
问答|Go sort包使用与源码剖析
Go中国
05-14 435
目录 包方面sort包里包括哪些文件sort.go如何使用，有什么需要注意的地方example_*_test.go格式的文件是做什么用的slice.go如何使用，有什么...
fortran打印n阶魔幻方阵
最新发布
10-09
好的，这是一个用Fortran打印n阶魔幻方阵的示例代码： ```fortran program magic_square implicit none integer :: size, i, j, k, r, c integer, allocatable :: square(:,:) ! 输入方阵的阶数 write(*, *) ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值