1.冒泡排序

func bubble_sort(li []int) {
for i := 0; i < len(li)-1; i++ {
exchange := false
for j := 0; j < len(li)-i-1; j++ {
if li[j] > li[j+1] {
li[j], li[j+1] = li[j+1], li[j]
exchange = true
}
}
if !exchange {
return
}
}
}

2.选择排序

func select_sort(li []int) {
for i := 0; i < len(li)-1; i++ {
pos := i
for j := i + 1; j < len(li); j++ {
if li[pos] > li[j] {
pos = j
}
}
li[i], li[pos] = li[pos], li[i]
}
}

3.插入排序

func insert_sort(li []int) {
for i := 1; i < len(li); i++ {
tmp := li[i]
j := i - 1
for j >= 0 && tmp < li[j] {
li[j+1] = li[j]
j --
}
li[j+1] = tmp
}
}

4.希尔排序

func shell_sort(li []int) {
for gap := len(li) / 2; gap > 0; gap /= 2 {
for i := gap; i < len(li); i++ {
tmp := li[i]
j := i - gap
for j >= 0 && tmp < li[j] {
li[j+gap] = li[j]
j -= gap
}
li[j+gap] = tmp
}
}
}

5.快速排序

func quick_sort(li []int, left, right int) {
if left >= right {
return
}
i := left
j := right
rand.Seed(time.Now().Unix())
r := rand.Intn(right-left) + left
li[i], li[r] = li[r], li[i]
tmp := li[i]
for i < j {
for i < j && li[j] >= tmp {
j--
}
li[i] = li[j]
for i < j && li[i] <= tmp {
i++
}
li[j] = li[i]
}
li[i] = tmp
quick_sort(li, left, i-1)
quick_sort(li, i+1, right)
}

6.堆排序

func sift(li []int, low, high int) {
i := low
j := 2*i + 1
tmp:=li[i]
for j <= high {
if j < high && li[j] < li[j+1] {
j++
}
if tmp < li[j] {
li[i] = li[j]
i = j
j = 2*i + 1
} else {
break
}
}
li[i] = tmp
} func heap_sort(li []int) {
for i := len(li)/2 - 1; i >= 0; i-- {
sift(li, i, len(li)-1)
}
for j := len(li) - 1; j > 0; j-- {
li[0], li[j] = li[j], li[0]
sift(li, 0, j-1)
}
}

7.归并排序

func merge(li []int, left, mid, right int) {
i := left
j := mid + 1
tmp := []int{}
for i <= mid && j <= right {
if li[i] <= li[j] {
tmp = append(tmp, li[i])
i ++
} else {
tmp = append(tmp, li[j])
j ++
}
}
if i <= mid {
tmp = append(tmp, li[i:mid+1]...)
} else {
tmp = append(tmp, li[j:right+1]...)
}
for k := 0; k < len(tmp); k++ {
li[left+k] = tmp[k]
}
} func merge_sort(li []int, left, right int) {
if left < right {
mid := (left + right) / 2
merge_sort(li, left, mid)
merge_sort(li, mid+1, right)
merge(li, left, mid, right)
}
}

8.计数排序

func count_sort(li []int) {
max_num := li[0]
for i := 1; i < len(li); i++ {
if max_num < li[i] {
max_num = li[i]
}
}
arr := make([]int, max_num+1)
for j := 0; j < len(li); j++ {
arr[li[j]]++
}
k := 0
for m, n := range arr {
for p := 0; p < n; p++ {
li[k] = m
k++
}
}
}

9.桶排序

func bin_sort(li []int, bin_num int) {
min_num, max_num := li[0], li[0]
for i := 0; i < len(li); i++ {
if min_num > li[i] {
min_num = li[i]
}
if max_num < li[i] {
max_num = li[i]
}
}
bin := make([][]int, bin_num)
for j := 0; j < len(li); j++ {
n := (li[j] - min_num) / ((max_num - min_num + 1) / bin_num)
bin[n] = append(bin[n], li[j])
k := len(bin[n]) - 2
for k >= 0 && li[j] < bin[n][k] {
bin[n][k+1] = bin[n][k]
k--
}
bin[n][k+1] = li[j]
}
o := 0
for p, q := range bin {
for t := 0; t < len(q); t++ {
li[o] = bin[p][t]
o++
}
}
}

10.基数排序

func radix_sort(li []int) {
max_num := li[0]
for i := 0; i < len(li); i++ {
if max_num < li[i] {
max_num = li[i]
}
}
for j := 0; j < len(strconv.Itoa(max_num)); j++ {
bin := make([][]int, 10)
for k := 0; k < len(li); k++ {
n := li[k] / int(math.Pow(10, float64(j))) % 10
bin[n] = append(bin[n], li[k])
}
m := 0
for p := 0; p < len(bin); p++ {
for q := 0; q < len(bin[p]); q++ {
li[m] = bin[p][q]
m++
}
}
}
}

11.用堆排解决top_k问题,思路:

  a.先取前k个数建小根堆,这样就能保证堆顶元素是整个堆的最小值;

  b.然后遍历列表的k到最后,如果值比堆顶大,就和堆顶交换,交换完后再对堆建小根堆,这样就能保证交换完后,堆顶元素仍然是整个堆的最小值;

  c.一直遍历到列表的最后一个值,这一步做完之后,就保证了整个列表最大的前k个数已经放进了堆里;

  d.按数的大到小出堆;

func sift(li []int, low, high int) {
i := low
j := 2*i + 1
tmp := li[i]
for j <= high {
if j < high && li[j] > li[j+1] {
j++
}
if tmp > li[j] {
li[i] = li[j]
i = j
j = 2*i + 1
} else {
break
}
}
li[i] = tmp
} func top_k(li []int, k int) []int {
for i := k/2 - 1; i >= 0; i-- {
sift(li, i, k-1)
}
for j := k; j < len(li); j++ {
if li[0] < li[j] {
li[0], li[j] = li[j], li[0]
sift(li, 0, k-1)
}
}
for n := k - 1; n > 0; n-- {
li[0], li[n] = li[n], li[0]
sift(li, 0, n-1)
}
return li[:k]
}

Go之十大经典排序算法的更多相关文章

  1. 十大经典排序算法(python实现)(原创)

    个人最喜欢的排序方法是非比较类的计数排序,简单粗暴.专治花里胡哨!!! 使用场景: 1,空间复杂度 越低越好.n值较大: 堆排序 O(nlog2n) O(1) 2,无空间复杂度要求.n值较大: 桶排序 ...

  2. 十大经典排序算法+sort排序

    本文转自:十大经典排序算法,其中有动图+代码详解,本文简单介绍+个人理解. 排序算法 经典的算法问题,也是面试过程中经常被问到的问题.排序算法简单分类如下: 这些排序算法的时间复杂度等参数如下: 其中 ...

  3. 十大经典排序算法的 JavaScript 实现

    计算机领域的都多少掌握一点算法知识,其中排序算法是<数据结构与算法>中最基本的算法之一.排序算法可以分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大 ...

  4. JavaScript 数据结构与算法之美 - 十大经典排序算法汇总(图文并茂)

    1. 前言 算法为王. 想学好前端,先练好内功,内功不行,就算招式练的再花哨,终究成不了高手:只有内功深厚者,前端之路才会走得更远. 笔者写的 JavaScript 数据结构与算法之美 系列用的语言是 ...

  5. 一文搞定十大经典排序算法(Java实现)

    本文总结十大经典排序算法及变形,并提供Java实现. 参考文章: 十大经典排序算法总结(Java语言实现) 快速排序算法—左右指针法,挖坑法,前后指针法,递归和非递归 快速排序及优化(三路划分等) 一 ...

  6. 十大经典排序算法最强总结(含JAVA代码实现)(转)

    十大经典排序算法最强总结(含JAVA代码实现)   最近几天在研究排序算法,看了很多博客,发现网上有的文章中对排序算法解释的并不是很透彻,而且有很多代码都是错误的,例如有的文章中在“桶排序”算法中对每 ...

  7. 十大经典排序算法(Javascript实现)

    前言 总括: 本文结合动图详细讲述了十大经典排序算法用Javascript实现的过程. 原文博客地址:十大经典排序算法 公众号:「菜鸟学前端」,回复「666」,获取一揽子前端技术书籍 人生有情泪沾衣, ...

  8. python实现十大经典排序算法

    Python实现十大经典排序算法 代码最后面会给出完整版,或者可以从我的Githubfork,想看动图的同学可以去这里看看: 小结: 运行方式,将最后面的代码copy出去,直接python sort. ...

  9. 用Python实现十大经典排序算法-插入、选择、快速、冒泡、归并等

    本文来用图文的方式详细讲解了Python十大经典排序算法 —— 插入排序.选择排序.快速排序.冒泡排序.归并排序.希尔排序.插入排序.桶排序.基数排序.计数排序算法,想要学习的你们,继续阅读下去吧,如 ...

  10. 十大经典排序算法最强总结(含Java、Python码实现)

    引言 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法.排序算法在很多领域得到相当地重视,尤其是在大量数据的处理方面 ...

随机推荐

  1. 微信, qq 支付宝 等相关开发 资源 记录

    手机QQweb开发平台  api : http://open.mobile.qq.com/api/component/share qq 微信  分享 简介 :https://segmentfault. ...

  2. Prometheus-Consul-Api

    官方地址:https://www.consul.io/docs/agent/http.html consul的主要接口是RESTful HTTP API,该API可以用来增删查改nodes.servi ...

  3. 视频显著性检测-----Predicting Video Saliency using Object-to-Motion CNN and Two-layer Convolutional LSTM

    帧内显著性检测: 将卷积网络的多层特征进行组合通过unsampling 得到粗显著性预测: 帧间显著性检测: (粗检测结果+新卷积网络的特征图,最后+之前卷积网络的卷积特征输入到LSTM中)进行预测. ...

  4. Learn Node.js

    Learn Node.js Node: 脱离浏览器运行的JS,运行在服务端 基于Chrome浏览器的V8引擎,使用V8虚拟机解析和执行JS代码 创建简单的服务器: 创建一个server.js的文件 $ ...

  5. subset_lat_dir.sh

    #!/bin/bash     # Copyright 2018 Jarvan Wang # Copyright 2017 Vimal Manohar # Apache 2.0.     cmd=ru ...

  6. django数据库迁移报错

    当输入C:\Users\太阳之泪\b2p\my_pro>python manage.py makemigrations shop 出现一下情况 然后输入C:\Users\太阳之泪\b2p\my_ ...

  7. 【译】索引进阶(十二):SQL SERVER中的索引碎片【中篇】

    原文链接:传送门. 为了讨论碎片产生的原因,以及避免和移除索引碎片的技术,我们必须从本进阶系列后续将介绍的两个章节借用一些知识点:创建/更新索引的知识,以及向一个索引表插入数据行的相关知识. 当我们讲 ...

  8. JSR-303 数据校验学习

    一.JSR-303简介JSR-303 是 JAVA EE 6 中的一项子规范,叫做 Bean Validation,官方参考实现是Hibernate Validator. 此实现与 Hibernate ...

  9. 关于codeforces国内访问卡顿慢的最新解决办法,谷歌字体库/屏蔽facebook链接

    在host里最后加上 方法起源来自于https://blog.csdn.net/qq_40693171/article/details/83623409 但是里面的360字体库已经停运http://w ...

  10. TestNg框架基础入门

    TestNg框架简介: TestNG,即Testing, Next Generation,下一代测试技术,是一套根据JUnit 和NUnit思想而构建的利用注释来强化测试功能的一个测试框架.TestN ...