Go语言中文网 为您找到相关结果 135

map按key和按value排序

看一个题: 查找和排序 题目:输入任意(用户,成绩)序列,可以获得成绩从高到低或从低到高的排列,相同成绩 都按先录入排列在前的规则处理。 例示: jack 70 peter 96 Tom 70 smith 67 从高到低 成绩 peter 96 jack 70 Tom 70 smith 67 从低到高 smith 67 Tom 70 jack 70 peter 96 1、按照value排序 2、可以递增排序和递减排序 3、保证排序的稳定性 golang map按key排序 //golang的map不保证有序性,所以按key排序需要取出key,对key排序,再遍历输出value package main import ( "fmt" "sort" ) func main() { // To c...阅读全文

博文 2017-07-31 04:06:16 zengfan

go语言的排序和搜索

晚上准备动手写点 go 的程序的时候,想起 go 如何排序的问题。排序 sort 是个基本的操作,当然搜索 search 也是。c 提供一个 qsort 和 bsearch,一个快排一个二分查找,不过是使用起来都不方便; c++ 中的 sort 貌似很不错,因为 c++ 支持泛型(或是说模板),所以很多东西使用起来很方便。go 是通过 sort 包提供排序和搜索,因为 go 暂时不支持泛型(将来也不好说支不支持),所以,go 的 sort 和 search 使用起来跟类型是有关的,或是需要像 c 一样写比较函数等,稍微显得也不是很方便。 补注: 近来又看 go 的排序, 发现以前对 go 的排序理解的有点浅了。 go 的排序思路和 c 和 c++ 有些差别。 c 默认是对数组进行排序, c+...阅读全文

博文 2014-10-24 11:38:53 陆仁贾

golang实现冒泡排序

//BubbleSort.go package main import "fmt" func main() { values := []int{4, 93, 84, 85, 80, 37, 81, 93, 27,12} fmt.Println(values) BubbleAsort(values) BubbleZsort(values) } func BubbleAsort(values []int) { for i := 0; i < len(values)-1; i++ { for j := i+1; j < len(values); j++ { if values[i]>values[j]{ values[i],values[j] = values[j],values[i] } } }...阅读全文

博文 2016-02-23 03:00:00 leo8

Go简单排序

写代码的时候发现需要对map[int64]int64排序,golang中sort包来解决这个问题,下面是从网上找的2个例子,备忘下。 例子一: package main import ( "fmt" "sort" ) func main() { m := map[string]string{"b": "15", "z": "123123", "x": "sdf", "a": "12"} mk := make([]string, len(m)) i := 0 for k, _ := range m { mk[i] = k i++ } sort.SortStrings(mk) fmt.Println(mk) } 例子二: // A data structure to hold a key/val...阅读全文

博文 2014-10-09 16:54:28 Rhino(犀牛)

GO语言为结构体排序

package main import ( "fmt" "io/ioutil" "sort" "time" ) type info struct { Name string Time time.Time } type newlist []*info func main() { l, e := getFilelist("./") if e != nil { fmt.Println(e) } sort.Sort(newlist(l)) //调用标准库的sort.Sort必须要先实现Len(),Less(),Swap() 三个方法. for _, v := range l { fmt.Println("文件名:", v.Name, "修改时间:", v.Time.Unix()) } } func ...阅读全文

博文 2015-11-07 12:00:05 fyxichen

go语言实现两个数组合并(merge)(二)

package main import ( "fmt" ) func Merge() { a := []int{3,6,9, 4,5,45} z := merge2(a, 0, 2, 5, 6) fmt.Printf("%#v\n", z) } //x数组,下标p,q,r 元素个数m。x[p]~x[q]及x[q+1]~x[r]已按递增排序 func merge2(x []int, p, q, r, m int) []int { z := make([]int, m) k := 0 a := q b := q + 1 for p if x[p] z[k] = x[p] p++ } else { z[k] = x[b] b++ } k++ } for p != a+1 { z[k] = x[p]...阅读全文

博文 2014-10-04 19:26:25 zongjh

go语言实现7大排序算法

package main import ( "fmt" "math/rand" "time" // "os" // "os/signal" ) const ( num = 100000 rangeNum = 100000 ) func main() { randSeed := rand.New(rand.NewSource(time.Now().Unix() + time.Now().UnixNano())) var buf []int for i := 0; i < num; i++ { buf = append(buf, randSeed.Intn(rangeNum)) } t := time.Now() //冒泡排序 // maopao(buf) // 选择排序 // xuanze(b...阅读全文

博文 2017-03-25 04:00:35 徐学良

睡眠排序--go实现

一次偶然的机会看见了睡眠排序,很有意思的一种排序算法,可以说是对我们熟悉的正规排序的一种挑战,是思想上的突破,有点像脑筋急转弯。使用睡眠排序算法,只能按照从小到大的顺序排列。打印数组中的数据时,按照其大小sleep,这样,数越大sleep的时间也就越长。所有的数同时进入sleep状态,数比较小的会提前打印出来。近期使用的都是GO语言,对其并发也有了些许理解,所以,使用go语言来实现这种排序,是很不错的选择。 // test project main.go package main import ( "fmt" "time" ) var flag bool var container chan bool var count int func main() { flag = true conta...阅读全文

博文 2014-10-04 19:26:02 lxy15329

快速排序

// QuickSort project main.go package main import ( "fmt" "math/rand" "time" ) func main() { var my_slice = make([]int, 0, 100) rand.Seed(int64(time.Now().Nanosecond())) for i := 0; i < 10; i++ { my_slice = append(my_slice, rand.Intn(1001)) } fmt.Println("Before The Quick Sort:") fmt.Println(my_sli...阅读全文

主题 2013-07-24 02:45:29 hrenlo

GO语言练习:第一个Go语言工程--排序

1、代码 2、编译 3、运行 1、代码框架 /home/fengbo/sorter $ tree . ├── bin ├── pkg ├── readme.txt └── src ├── algorithms │ ├── bubblesort │ │ ├── bubblesort.go │ │ └── bubblesort_test.go │ └── qsort │ ├── qsort.go │ └── qsort_test.go └── sorter └── sorter.go 1.1、src/algorithms/bubblesort/bubblesort.go //bubblesort.go package bubblesort func BubbleSort(values []int...阅读全文

博文 2015-07-05 03:00:01 fengbohello

golang实现直接插入排序算法

直接插入排序算法golang实现版本: 插入算法概要: 建立一个空的链表,首先在要排序的数组中随便拿出来一个数据,放在新建链表的开头,然后不停的从原数组中 获取数据,并和链表中的数据进行比较,大就放在链表的右端,小就放在链表的左端,一直循环直到结束为止, 排序完成。 package main import( "container/list" "fmt" ) var old []int = []int{432,432432,4234,333,333,21,22,3,30,8,20,2,7,9,50,80,1,4} func main(){ fmt.Println("old array:",old) res,_ := InsertionSort(old) i := 0 for e := res....阅读全文

博文 2014-10-04 19:26:08 rufidmx

go语言写的并行排序算法(快速排序)

package main import "fmt" // threads 线程标识创建线程的个数 func quicksort(nums []int, ch chan int, level int, threads int) { level=level*2 if len(nums) == 1 { ch<- nums[0]; close(ch); return }//ch<-nums[0] 表示将nums[0] 数据写到ch通道中 if len(nums) == 0 { close(ch); return } less := make([]int, 0)// greater := make([]int,0) left := nums[0] //快速排序的轴 nums = nums[1:] //...阅读全文

博文 2015-12-23 01:00:11 ZHONGHUNZHAIZHUREN

内部排序算法(Golang版本)

package main import ( "fmt" ) func main() { //保存需要排序的Slice arr := []int{9, 3, 4, 7, 2, 1, 0, 11, 12, 11, 13, 4, 7, 2, 1, 0, 11, 12, 11} //实际用于排序的Slice list := make([]int, len(arr)) copy(list, arr) BubbleSortX(list) fmt.Println("冒泡排序:\t", list) copy(list, arr) QuickSort(list, 0, len(arr)-1) fmt.Println("快速排序:\t", list) copy(list, arr) //将arr的数据覆盖到li...阅读全文

博文 2015-11-23 03:00:00 achst

Go语言:使用sort包对任意类型元素的集合进行排序

使用sort包的函数进行排序时,集合需要实现sort.Inteface接口,该接口中有三个方法: // 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) 以下为简单示例: //对任意对象进行排序 type Person struct { name string age ...阅读全文

博文 2015-06-17 23:02:08 books1958

堆排序算法及go语言实现

堆分最大堆、最小堆。 以最大堆为例。 最大堆是一个完全二叉树。 并且要求每个结点的值必须大于他的两个子节点。 所以他的根结点一定是最大值。 但是左右结点大小不一定。 用数组表示的二叉树,可以这样表达: i的子节点下标为 2*i + 1 和 2 * i + 2. i的父节点下标为 (i-1)/2。 对于数组长度length,大于length/2的下标一定没有子节点. 排序思想是构建最大堆,之后根节点就是最大的一个了,把根结点拿出来,再把剩下的堆整理成最大堆,再把根拿出来。循环直到最后一个元素。 func HeapSort(values []int) { buildHeap(values) for i := len(values); i > 1; i-- { values[0], values[...阅读全文

博文 2016-04-15 16:00:02 zhaoguoguang

go语言十大排序算法总结(下篇)

希尔排序 希尔排序基本思想: 先取一个小于n的整数d1作为第一个增量,把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插入排序;然后,取第二个增量d2《d1重复上述的分组和排序,直至所取的增量dt=1(dt《dt-l《…《d2《d1),即所有记录放在同一组中进行直接插入排序为止。 该方法实质上是一种分组插入方法。 个人总结: public class ShellSorter { public void Sort(int[] arr) { int inc; for (inc = 1; inc <= arr.Length / 9; inc = 3 * inc + 1) ; for (; inc > 0; inc /= 3) { for (int i = ...阅读全文

博文 2016-07-17 19:00:04 guoer9973

基本排序算法(Golang实现)

冒泡排序 func BubbleSort(vector []int) { fmt.Println("BubbleSort") fmt.Println(vector) for i := 0; i < len(vector); i++ { tag := true // 为了剪枝 // 每一趟将最大的数冒泡 for j := 0; j < len(vector)-i-1; j++ { if vector[j] > vector[j+1] { /*vector[j] < vector[j+1]*/ temp := vector[j] vector[j] = vector[j+1] vector[j+1] = temp tag = false } } if tag { break //0~len(ve...阅读全文

博文 2014-11-13 08:00:02 xlplbo

GOLANG版的快速排序与冒泡排序

一直很少接触算法之类的(我用的是PHP),今天突然看了一下,并用GO语言写了出来。非常喜欢GO语言,可能是有 一点GOOGLE情结吧~。发在这里记录下,也希望对跟我一样的初学者有所帮助。 下面是代码,注意在Go里传递Array参数会自动转换为Slice,而Slice是引用类型,排序算法的好坏我就不敢评价了,也不是很懂。 //冒泡排序 func mpSort(array []int) { for i:=0;i array[j+1] { array[j], array[j+1] = array[j+1], array[j] } } } } //快速排序 func quic...阅读全文

博文 2014-10-23 14:00:01 一曲忧伤

go语言十大排序算法总结

选择排序 选择排序的基本思想是对待排序的记录序列进行n-1遍的处理,第i遍处理是将L[i..n]中最小者与L[i]交换位置。这样,经过i遍处理之后,前i个记录的位置已经是正确的了。 选择排序是不稳定的。算法复杂度是O(n ^2 )。 package main import ( "fmt" ) type SortInterface interface { sort() } type Sortor struct { name string } func main() { arry := []int{6, 1, 3, 5, 8, 4, 2, 0, 9, 7} learnsort := Sortor{name: "选择排序--从小到大--不稳定--n*n---"} learnsort.sort(ar...阅读全文

博文 2016-07-16 17:00:00 guoer9973

golang sort 排序

package main import ( "fmt" "sort" ) func main() { d := []int{5, 2, 6, 3, 1, 4} // unsorted sort.Sort(sort.IntSlice(d)) fmt.Println(d) // Output:[1 2 3 4 5 6] a := []float64{5.5, 2.2, 6.6, 3.3, 1.1, 4.4} sort.Sort(sort.Float64Slice(a)) fmt.Println(a) // Output:[1.1 2.2 3.3 4.4 5.5 6.6] s := []string{"PHP", "golang", "python", "C", "Objective-C"} so...阅读全文

博文 2015-06-17 20:02:20 yatere

golang map sort

import ( "fmt" "sort")type MapSorter []Itemtype Item struct { Key string Val int64}func NewMapSorter(m map[string]int64) MapSorter { ms := make(MapSorter, 0, len(m)) for k, v := range m { ms = append(ms, Item{k, v}) } return ms}func (ms MapSorter) Len() int { return len(ms)}func (ms MapSorter) Less(i, j int) bool { return ms[i].Val < ms[j].Val // 按...阅读全文

博文 2018-08-01 22:34:51 夜空一起砍猩猩

Go语言实现冒泡和快速排序

冒泡和快速排序都属于交换类排序,所谓交换排序是指借助数据元素之间互相交换进行排序的方法。 冒泡排序法 冒泡排序法是一种最简单的交换类排序方法,它是通过相邻数据的交换逐步将线性表变成有序。 冒泡排序(BubbleSort)的基本概念是:依次比较相邻的两个数,将小数放在前面,大数放在后面。 即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。至此第一趟结束,将最大的数放到了最后。 在第二趟:仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换,使得第1个数不再小于第2个数),将小数放前,大数放后,一直比较到倒数第二个数(倒数第一的位置上已经是最大的), 第二趟结束,在倒数第二的位置...阅读全文

博文 2014-10-27 09:57:26 ghj1976

go语言的排序和搜索(转载)

http://studygolang.com/articles/1598 go语言的排序和搜索 晚上准备动手写点 go 的程序的时候,想起 go 如何排序的问题。排序 sort 是个基本的操作,当然搜索 search 也是。c 提供一个 qsort 和 bsearch,一个快排一个二分查找,不过是使用起来都不方便; c++ 中的 sort 貌似很不错,因为 c++ 支持泛型(或是说模板),所以很多东西使用起来很方便。go 是通过 sort 包提供排序和搜索,因为 go 暂时不支持泛型(将来也不好说支不支持),所以,go 的 sort 和 search 使用起来跟类型是有关的,或是需要像 c 一样写比较函数等,稍微显得也不是很方便。 补注: 近来又看 go 的排序, 发现以前对 go 的排序理...阅读全文

博文 2016-01-11 03:00:00 basque

GOLANG版的快速排序与冒泡排序

一直很少接触算法之类的(我用的是PHP),今天突然看了一下,并用GO语言写了出来。非常喜欢GO语言,可能是有 一点GOOGLE情结吧~。发在这里记录下,也希望对跟我一样的初学者有所帮助。 下面是代码,注意在Go里传递Array参数会自动转换为Slice,而Slice是引用类型,排序算法的好坏我就不敢评价了,也不是很懂。 //冒泡排序 func mpSort(array []int) { for i:=0;i array[j+1] { array[j], array[j+1] = array[j+1], array[j] } } } } //快速排序 func quic...阅读全文

博文 2014-10-21 10:00:02 一曲忧伤

golang slice 排序

如下示例为,在一个Person切片中,按年龄大小进行排序 package main import ( "fmt" "sort" ) /*slice 排序示例*/ type Person struct { Age int } type PersonSlice []Person func (s PersonSlice) Len() int { return len(s) } func (s PersonSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } func (s PersonSlice) Less(i, j int) bool { return s[i].Age < s[j].Age } func main() { persons := Pe...阅读全文

博文 2018-11-13 22:34:39 小风吹的我乱了

【Go语言】基本类型排序和 slice 排序

Go 是通过 sort 包提供排序和搜索,因为 Go 暂时不支持泛型(将来也不好说支不支持),所以,Go 的 sort 和 search 使用起来跟类型是有关的,或是需要像 c 一样写比较函数等,稍微显得也不是很方便。 引言 Go 的排序思路和 C 和 C++ 有些差别。 C 默认是对数组进行排序, C++ 是对一个序列进行排序, Go 则更宽泛一些,待排序的可以是任何对象, 虽然很多情况下是一个 slice (分片, 类似于数组),或是包含 slice 的一个对象。 排序(接口)的三个要素: 待排序元素个数 n ; 第 i 和第 j 个元素的比较函数 cmp ; 第 i 和 第 j 个元素的交换 swap ; 乍一看条件 3 是多余的, c 和 c++ 都不提供 swap 。 c 的 qs...阅读全文

博文 2016-09-22 05:00:02 u010983881

go语言 接口的思考(一)

在《学习Go语言》中,有一个例子,说得是怎样做一个通用的接口来实现给数字,字符串来排序。 第一种思路: 1. 定义一个函数,可以接收任意类型做为入参,然后 在函数内,根据入参来判断是那一个类型 func sort(i []interface{}) { switch i.(type) { case string: // ... case int // ... 来实现 } } 在调用时,sort([]int{1, 4, 5}) 我们传入了一个数组, 很不幸,Go不能(隐式)转换为slice。 所以上述方法行不通。 换种思路: 1. 先定义一个接口Sorter,这个接口中包含了方法列表 即使是没有具体实现这个方法,这个接口也是合法的。 2. 定义一个函数Sort 入参是Sorter类型。 接口也是...阅读全文

博文 2014-10-04 19:26:04 zistxym

算法代码实现之堆排序,Golang(Go语言)实现

封装成函数: //堆排序//s[0]不用,实际元素从角标1开始//父节点元素大于子节点元素//左子节点角标为2*k//右子节点角标为2*k+1//父节点角标为k/2func HeapSort(s []int) { N := len(s) - 1 //s[0]不用,实际元素数量和最后一个元素的角标都为N //构造堆 //如果给两个已构造好的堆添加一个共同父节点, //将新添加的节点作一次下沉将构造一个新堆, //由于叶子节点都可看作一个构造好的堆,所以 //可以从最后一个非叶子节点开始下沉,直至 //根节点,最后一个非叶子节点是最后一个叶子 //节点的父节点,角标为N/2 for k := N / 2; k >= 1; k-- { sink(s, k, N) } //下沉排序 for N > ...阅读全文

博文 2016-03-01 21:00:00 QQ245671051

GO语言quicksort实现.快速排序法代码实现

package main import ( "fmt" "math/rand" "time" ) func main() { var z []int for i := 0; i < 1000000; i++ { z = append(z, rand.Intn(100000)) } sort(z) } func sort(list []int) { if len(list) <= 1 { return//退出条件 } i, j := 0, len(list)-1 index := 1 //表示第一次比较的索引位置. key := list[0] //第一次比较的参考值.这里选择第一个数 if list[index] > key { list[i], list[j] = list[j], lis...阅读全文

博文 2015-06-23 11:01:29 fyxichen

quick sort in golang

package main import ( "fmt" ) func QuickSort(src []int, first, last int) { flag := first left := first right := last if first >= last { return } for first < last { //从最右边开始向前找比选取的标记值小的数字,然后进行交换,并记下标记值的新index for first < last { if src[last] >= src[flag] { last -= 1 continue } else { tmp := src[last] src[last] = src[flag] src[flag] = tmp flag = last ...阅读全文

博文 2015-06-18 17:04:36 rufidmx

go语言的排序和搜索

晚上准备动手写点 go 的程序的时候,想起 go 如何排序的问题。排序 sort 是个基本的操作,当然搜索 search 也是。c 提供一个 qsort 和 bsearch,一个快排一个二分查找,不过是使用起来都不方便; c++ 中的 sort 貌似很不错,因为 c++ 支持泛型(或是说模板),所以很多东西使用起来很方便。go 是通过 sort 包提供排序和搜索,因为 go 暂时不支持泛型(将来也不好说支不支持),所以,go 的 sort 和 search 使用起来跟类型是有关的,或是需要像 c 一样写比较函数等,稍微显得也不是很方便。 补注: 近来又看 go 的排序, 发现以前对 go 的排序理解的有点浅了。 go 的排序思路和 c 和 c++ 有些差别。 c 默认是对数组进行排序, c+...阅读全文

博文 2015-07-27 13:00:01 nop4ss

算法代码实现之希尔排序,Golang(Go语言)实现

封装成函数: func ShellSort(a []int) { n := len(a) h := 1 for h < n/3 { //寻找合适的间隔h h = 3*h + 1 } for h >= 1 { //将数组变为间隔h个元素有序 for i := h; i < n; i++ { //间隔h插入排序 for j := i; j >= h && a[j] < a[j-h]; j -= h { swap(a, j, j-h) } } h /= 3 }} func swap(slice []int, i int, j int) { slice[i], slice[j] = slice[j], slice[i]} 测试: s := []int{9,0,6,5,8,2,1,7,4,3}fmt....阅读全文

博文 2016-02-28 18:00:01 QQ245671051

算法代码实现之插入排序,Golang(Go语言)实现

封装成函数: //插入排序func InsertionSort(s []int) { n := len(s) if n < 2 { return } for i := 1; i < n; i++ { for j := i; j > 0 && s[j] < s[j - 1]; j-- { swap(s, j, j - 1) } }} func swap(slice []int, i int, j int) { slice[i], slice[j] = slice[j], slice[i]} 测试: s := []int{9,0,6,5,8,2,1,7,4,3}fmt.Println(s)InsertionSort(s)fmt.Println(s) 输出: [9 0 6 5 8 2 1 7 4 ...阅读全文

博文 2016-02-28 16:00:00 QQ245671051

golang 中sort包sort.search()使用教程

使用sort包中Sort()函数的时候 cannot use c.ring (type []uint32) as type sort.Interface in argument to sort.Sort: []uint32 does not implement sort.Interface (missing Len method) cannot use c.ring (type []uint32) as type sort.Interface in argument to sort.Sort: []uint32 does not implement sort.Interface (missing Len method) 原因是sort.Sort()的定义如下 func Sort(data I...阅读全文

博文 2018-08-15 00:34:58 豆瓣奶茶

第一次来博客园,来两个排序算法热热身(golang冒泡排序和快速排序)

第一次来到博客园,属于比较晚了,毕业前后从事开发已有4年,学到了一些东西,但是发现需要学的东西更多了。先来两个基础的排序算法热热身 一.冒泡排序,向后移动,从小到大排序,其思想为相邻两个数进行比较,将较大的滞后,时间复杂度O(N^2) package main import ( "fmt" ) func main() { array := [11]int{56,45,9,16,2,89,78,34,102,56,99} fmt.Print("排序前:") fmt.Println(array) length := len(array) for i := 0; i < length; i++ { for j := 0; j < length-1-i; j++ { if array[j] > ar...阅读全文

博文 2016-05-11 11:00:01 robotcoming

排序算法详解(Go语言实现):冒泡排序/选择排序/快速排序/插入排序

算法是程序的灵魂,而排序算法则是一种最基本的算法。排序算法有许多种,本文介绍4中排序算法:冒泡排序,选择排序,快速排序和插入排序,以从小到大为例。 一、冒泡排序 冒泡排序的原理是,对给定的数组进行多次遍历,每次均比较相邻的两个数,如果前一个比后一个大,则交换这两个数。经过第一次遍历之后,最大的数就在最右侧了;第二次遍历之后,第二大的数就在右数第二个位置了;以此类推。 //冒泡排序(排序10000个随机整数,用时约145ms) func bubbleSort(nums []int) { for i := 0; i < len(nums); i++ { for j := 1; j < len(nums)-i; j++ { if nums[j] < nums[j-1] { //交换 nums[j]...阅读全文

博文 2015-06-17 23:07:39 books1958

基本排序算法Golang

摘要 排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。 冒泡排序 1 func BubbleSort(vector []int) { 2 fmt.Println("BubbleSort") 3 fmt.Println(vector) 4 for i := 0; i < len(vector); i++ { 5 tag := true // 为了剪枝 6 // 每一趟将最大的数冒泡 7 for j := 0; j < len(vector)-i-1; j++ { 8 if vector[j] > vector[j+1] { /*vector[j] < vector[j+1]*/ 9 temp :=...阅读全文

博文 2016-06-30 10:00:00 borey

Java、Scala、Go以相同方式实现快速排序代码量比较

在程序猿的世界,语言之争是个永恒的话题,在此,我想说:让争论来的更猛烈些吧。 在此,我要用相同的方式实现快速排序。首先,我们简单的回顾一下什么是快速排序。 快速排序: 快排的精髓在于”分治“。注意:这是两个方面,”分“讲的是利用所选的元素(往往是第一个元素,在此命名为Key),以Key为分水岭将列表分为:比Key元素大的和比Key元素小的两部分;”治“讲的是将分开的两部分以同样的方式(”分”的方式)继续排序,直至完全排完。如下图所示: 很显然,用“递归”的方式是很不错的。下面,每个语言用最最简洁的方式实现这个排序,然后比较一下代码量: 给出的需要排序的序列是:6、2、7、3、9、4、8、5 JAVA: private void setQuickSort(int[] array,int lef...阅读全文

博文 2016-03-04 16:00:00 i6448038

算法代码实现之冒泡排序,Golang(Go语言)实现

有两种相似的方式: func swap(slice []int, i int, j int) { slice[i], slice[j] = slice[j], slice[i]} //第一种冒泡排序func BubbleSort1(slice []int) { length := len(slice) max := length - 1 for i := 0; i < max; i++ { for j := 0; j < max-i; j++ { if slice[j+1] < slice[j] { swap(slice, j, j+1) } } }} //第二种冒泡排序func BubbleSort2(slice []int) { length := len(slice) max := l...阅读全文

博文 2016-02-27 21:00:00 QQ245671051

Go语言排序一千万个随机数.开的双核.用了120秒,不知道怎么优化.然后自己调整了一下参数跑了一下34秒

自己没事调整了一下参数,然后从新跑了一下,时间缩短为34秒,结果还可以. package main import ( "fmt" "os" "runtime" "test" "time" ) var x chan []int = make(chan []int, 1) var Num int = 10 //改为100 var WNum int = 100 func main() { fmt.Println(time.Now()) var list1, list2 []int var R chan []int = make(chan []int, 1) for i := 0; i < WNum; i++ { go Chan(Num, R) } for i := 0; i < WNum; i++...阅读全文

博文 2015-06-18 09:09:13 fyxichen

堆排序(golang实现)

封装成函数: //堆排序 //s[0]不用,实际元素从角标1开始 //父节点元素大于子节点元素 //左子节点角标为2*k //右子节点角标为2*k+1 //父节点角标为k/2 func HeapSort(s []int) { N := len(s) - 1 //s[0]不用,实际元素数量和最后一个元素的角标都为N //构造堆 //如果给两个已构造好的堆添加一个共同父节点, //将新添加的节点作一次下沉将构造一个新堆, //由于叶子节点都可看作一个构造好的堆,所以 //可以从最后一个非叶子节点开始下沉,直至 //根节点,最后一个非叶子节点是最后一个叶子 //节点的父节点,角标为N/2 for k := N / 2; k >= 1; k-- { sink(s, k, N) } //下沉排序 fo...阅读全文

博文 2017-09-03 07:05:01 imroc

Golang快速排序算法

package main import ( "fmt" ) func QSort(arr []int, start int, end int) { var ( key int = arr[start] low int = start high int = end ) for { for low < high { if arr[high] < key { arr[low] = arr[high] break } high-- } for low < high { if arr[low] > key { arr[high] = arr[low] break } low++ } if low >= high { arr[low] = key break } } if low-1 > start {...阅读全文

博文 2015-06-18 17:04:31 u011774512

Golang语言常用算法

在学习golang语言,文档看的实在是乏味,就想着把常用的算法做个实现,边写变学习,想来效果还是不错的! 1. 堆排序 package main import "fmt" func buildHeap(array []int, length int) { var i, j int; for i = 1; i < length; i = i + 1 { for j = i; j > 0 && array[j] > array[(j-1)/2]; j = (j - 1)/2 { array[j], array[(j-1)/2] = array[(j-1)/2], array[j] } } } func heapSort(array []int, length int) { array[0], a...阅读全文

博文 2017-02-22 09:00:11 wujieyhy2006

算法代码实现之三向切分快速排序,Golang(Go语言)实现

封装成函数: //三向切分快速排序func ThreeWayQuickSort(s []int) { sort3way(s, 0, len(s)-1)} //在lt之前的(lo~lt-1)都小于中间值//在gt之前的(gt+1~hi)都大于中间值//在lt~i-1的都等于中间值//在i~gt的都还不确定(最终i会大于gt,即不确定的将不复存在)func sort3way(s []int, lo, hi int) { if lo >= hi { return } v, lt, i, gt := s[lo], lo, lo+1, hi for i <= gt { if s[i] < v { swap(s, i, lt) lt++ i++ } else if s[i] > v { swap(s, ...阅读全文

博文 2016-02-29 22:00:02 QQ245671051

[golang] 数据结构-希尔排序

除了上篇介绍的二分插入排序,还有这次介绍的希尔排序(Shell's Sort),也是对直接插入排序算法的优化。 原理希尔排序,就是按某个增量值对数据进行分组,每组单独排序好后,再缩小这个增量,然后按新增量对数据分组后每个分组再各自排序。最终增加缩小到1的时候,排序结束。所以希尔排序又叫缩小增量排序(Diminishing Increment Sort) 关于增量最佳增量值的选择其实是个数学难题,有兴趣的可以自己搜下相关资料。常用的增量有 n/2(这个又叫希尔增量)、n/3、2^k-1(hibbard增量)等,实际使用中稍微改版增量也可能使排序的性能产生很大的波动。比如使用n/2的增量,就是初始增量就是 length/2 ,第二轮分组时就再除2:length/4,直至增量值变成1 流程假设有个...阅读全文

博文 2018-07-28 00:35:48 NicoChen

Let's go to play (模拟)

Let's go to play Time Limit : 3000/1000ms (Java/Other) Memory Limit : 65535/32768K (Java/Other) Total Submission(s) : 771 Accepted Submission(s) : 213 Font: Times New Roman | Verdana | Georgia Font Size: ← → Problem Description Mr.Lin would like to hold a party and invite his friends to this party. He has n friends and each of them can come in a sp...阅读全文

博文 2016-04-02 17:00:05 yanghui07216