GO语言中常见的排序算法使用示例

目录
  • 快排
  • 冒泡
  • 选择排序
  • 插入排序
  • 希尔排序
  • 二分法查找

快排

package main
import (
	"fmt"
	"math/rand"
	"time"
)
func main() {
	li:=[]int{1,3,5,2,4,6,9,7}
	left:=0
	right:=len(li)-1
	fmt.Println(quick_sort(li,left,right))
}
func quick_sort(li []int, left,right int) []int {
	if left<right{
		mid := paitition(li,left,right)
		quick_sort(li,left,mid-1)
		quick_sort(li,mid+1,right)
	}
	return li
}
func paitition(li []int, left,right int) int {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	res := r.Intn(right-left+1)+left
	li[left],li[res] = li[res],li[left]
	temp:=li[left]
	for left<right {
		for left<right && li[right]>=temp{
			right-=1
		}
		li[left]=li[right]
		for left<right && li[left]<=temp{
			left+=1
		}
		li[right]=li[left]
	}
	li[left]=temp
	return left
}

冒泡

package main
import "fmt"
func main()  {
	li:=[]int{1,3,5,2,4,6,9,7}
	fmt.Println(bubble_sort(li))
}
func bubble_sort(li[]int) []int {
	for i:=0;i<len(li)-1;i++ {
		res:=true
		for j:=0;j<len(li)-1-i;j++{
			if li[j]>li[j+1]{
				li[j],li[j+1]=li[j+1],li[j]
				res=false
			}
		}
		if res{
			return li
		}
	}
	return nil
}

选择排序

package main
import "fmt"
func main()  {
	li:=[]int{1,3,5,2,4,6,9,7}
	fmt.Println(select_sort(li))
}
func select_sort(li[]int) []int {
	for i:=0;i<len(li);i++ {
		min_loc := i
		for j:=i+1;j<len(li);j++ {
			if li[j]<li[min_loc] {
				min_loc=j
			}
		}
		if min_loc!=i {
			li[i],li[min_loc]=li[min_loc],li[i]
		}
	}
	return li
}

插入排序

package main
import "fmt"
func main()  {
	li:=[]int{1,3,201,5,2,100,4,6,9,7,2}
	fmt.Println(insert_sort(li))
}
func insert_sort(li[]int) []int {
	for i:=1;i<len(li); i++{
		tmp:=li[i]
		j := i-1
		for j>0 && li[j]>tmp {
			li[j+1]=li[j]
			j=j-1
		}
		li[j+1] = tmp
	}
	return li
}

希尔排序

package main
import "fmt"
func main()  {
	li:=[]int{1,3,201,5,2,100,4,6,9,7,2}
	fmt.Println(shell_sort(li))
}
func shell_sort(li[]int) []int {
	res := len(li)/2
	for res>0 {
		for i:=res;i<len(li);i++{
			tmp := li[i]
			j := i-res
			for j>=0 && tmp <li[j]{
				li[j+res] = li[j]
				j -= res
			}
			li[j+res] = tmp
		}
		res /=2  //res = res/2
	}
	return li
}

二分法查找

package main
import "fmt"
func main()  {
	li:=[]int{1,2,3,4,5,6,7,8}
	left:=0
	right:=len(li)-1
	value := 8
	fmt.Println(bin_search(li,value,left,right))
}
func bin_search(li[]int,value,left,right int) int {
	if left <=right{
		mid := (left+right)/2
		if li[mid] == value{
			return mid
		} else if li[mid]>value {
			return bin_search(li,value,left,mid-1)
		} else {
			return bin_search(li,value,mid+1,right)
		}
	} else {
		return 999
	}
}

以上就是GO语言中常见的排序算法使用示例的详细内容，更多关于GO语言排序算法的资料请关注我们其它相关文章！

赞 (0)

相关推荐

  • go语言睡眠排序算法实例分析

    本文实例讲述了go语言睡眠排序算法.分享给大家供大家参考.具体分析如下: 睡眠排序算法是一个天才程序员发明的,想法很简单,就是针对数组里的不同的数开多个线程,每个线程根据数的大小睡眠,自然睡的时间越长的,数越大,哈哈,搞笑吧,这种算法看起来很荒唐,但实际上很天才,它可以充分利用多核cpu进行计算. 复制代码 代码如下: package main import (     "fmt"     "time" ) func main() {     tab := []in

  • 深入解析快速排序算法的原理及其Go语言版实现

    深入解析快速排序算法的原理及其Go语言版实现

    快速排序是一种基于分治技术的重要排序算法.不像归并排序是按照元素在数组中的位置对它们进行划分,快速排序按照元素的值对它们进行划分.具体来说,它对给定数组中的元素进行重新排列,以得到一个快速排序的分区.在一个分区中,所有在s下标之前的元素都小于等于A[s],所有在s下标之后的元素都大于等于A[s]. 显然,建立了一个分区以后,A[s]已经位于它在有序数组中的最终位置,接下来我们可以继续对A[s]前和A[s]后的子数组分别进行排序(使用同样的方法). 为了排序一个数组A的全部元素,初始调用的是QUI

  • go实现冒泡排序算法

    go实现冒泡排序算法

    目录 1.基本思想 2.算法步骤 第一轮开始排序: 第二轮开始排序: 第三轮开始排序: 第四轮开始排序: 3.算法实现 1.基本思想 通过对待排序序列从后向前,依次比较相邻元素的排序码,若发现逆序则交换,使排序码较小的元素从后部移向前部,就像水底气泡一样逐渐向上冒. 通俗点说就是:数组中前一个元素和后一个元素进行比较如果大于或者小于前者就进行交换,最终返回最大或者最小都冒到数组的最后序列时间复杂度为O(n^2). 比较的次数为: 从比较次数上可以看出,是一个平方级别的时间复杂度: 冒泡排序算法是

  • stl常用算法(Algorithms)介绍(stl排序算法、非变序型队列)

    stl常用算法(Algorithms)介绍(stl排序算法、非变序型队列)

    算法:用来处理群集内的元素.它们可以出于不同的目的而搜寻,排序,修改,使用那些元素.是一种应用在容器上以各种方法处理其内存的行为或功能,如sort(排序),copy(拷贝)- 算法由模板函数体现,这些函数不是容器类的成员函数,是独立的函数,它们可以用于STL容器,也可以用于普通的C++数组等. 头文件:#include<algorithm> 在STL的泛型算法中有4类基本的算法: 1)变序型队列算法: 可以改变容器内的数据: 2)非变序型队列算法:处理容器内的数据而不改变他们: 3)排序值算法

  • Go归并排序算法的实现方法

    Go归并排序算法的实现方法

    目录 归并排序的思想 归并排序的 Go 代码实现 归并排序的时间复杂度 今天继续基础排序算法的图解和Go 代码实现,这次分享一个时间复杂度为*** 诶,时间复杂度多少先保密,文末会有分析.这次分享的排序算法是—归并排序(Merge Sort). 归并排序的思想 与快速排序一样,归并排序采用的也是分治的策略,把原本的问题先分解成一些小问题进行求解,再把这些小问题各自的答案修整到一起得到原本问题的答案,从而达到分而治之的目的. 归并排序算法会把要排序的序列分成长度相当的两个子序列,当分无可分每个子序

  • Go语言排序算法之插入排序与生成随机数详解

    前言 排序,对于每种编程语言都是要面对的.这里跟大家一起分享golang实现一些排序算法,并且说明如何生成随机数.下面话不多说了,来一起看看详细的介绍吧. 经典排序算法 算法的学习非常重要,是检验一个程序员水平的重要标准.学习算法不能死记硬背,需要理解其中的思想,这样才能灵活应用到实际的开发中. 七大经典排序算法 插入排序 选择排序 冒泡排序 希尔排序 归并排序 堆排序 快速排序 插入排序 先考虑一个问题:对于长度为n的数组,前n-1位都是递增有序的,如何排序? 1.从第1位至第n-1位遍历数组

  • Go语言展现快速排序算法全过程的思路及代码示例

    快速排序算法 快速排序是一个递归的思想,首先选择一个数作为基数,把数组中小于它的数放在它的左边,把大于它的数放在它的右边,然后对左右两边的数递归进行排序. 算法的关键部分是实现数组的划分,即怎么把数组的元素划分成两部分,使得左边的数比基数小,右边的数比基数大.划分有许多不同的实现方法,这里主要使用单向扫描的方法,后面再稍微介绍双向扫描的方法. 选择最右边的数字作为基数.使用一个变量j记录当前左边数字(比基数小的数)的最右的下标值.然后使用变量i从左到右遍历数组,如果a[i]比基数小,说明a[i]

  • Golang正整数指定规则排序算法问题分析

    本文实例讲述了Golang正整数指定规则排序算法问题.分享给大家供大家参考,具体如下: 给定字符串内有很多正整数,要求对这些正整数进行排序,然后返回排序后指定位置的正整数 排序要求:按照每个正整数的后三位数字组成的整数进行从小到大排序 1)如果不足三位,则按照实际位数组成的整数进行比较 2)如果相等,则按照输入字符串中的原始顺序排序 说明(以下内容考生无须检查,调用者保证): 1) 字符串内正整数之间以单个空格分隔,字符串首尾没有空格 2) 正整数格式为十进制,大小:1~1000000,正整数的

  • JS中数据结构与算法---排序算法(Sort Algorithm)实例详解

    排序算法的介绍 排序也称排序算法 (Sort Algorithm),排序是将 一组数据 , 依指定的顺序 进行 排列的过程 . 排序的分类 1)  内部排序 : 指将需要处理的所有数据都加载 到 内部存储器(内存) 中进行排序. 2) 外部排序法: 数据量过大,无法全部加载到内 存中,需要借助 外部存储(文件等) 进行 排序. 常见的排序算法分类 算法的时间复杂度 度量一个程序(算法)执行时间的两种方法 1.事后统计的方法 这种方法可行, 但是有两个问题:一是要想对设计的算法的运行性能进行评测,

  • GO语言中常见的排序算法使用示例

    目录 快排 冒泡 选择排序 插入排序 希尔排序 二分法查找 快排 package main import ( "fmt" "math/rand" "time" ) func main() { li:=[]int{1,3,5,2,4,6,9,7} left:=0 right:=len(li)-1 fmt.Println(quick_sort(li,left,right)) } func quick_sort(li []int, left,right

  • Java实现常见的排序算法的示例代码

    目录 一.优化后的冒泡排序 二.选择排序 三.插入排序 四.希尔排序 五.快速排序 六.随机化快速排序 七.归并排序 八.可处理负数的基数排序 一.优化后的冒泡排序 package com.yzh.sort; /* 冒泡排序 */ @SuppressWarnings({"all"}) public class BubbleSort { public static void BubbleSort(int[]a){ for (int i = 0; i <a.length-1 ; i+

  • 深入学习C语言中常见的八大排序

    深入学习C语言中常见的八大排序

    目录 冒泡排序 1.算法描述 2.动图展示 3.图解展示 4.代码实现 5.冒泡排序的优化 6.复杂度分析 插入排序 1.算法描述 2.动图展示 3.图解展示 4.代码实现 5.复杂度分析 希尔排序 1.算法描述 2.动图展示 3.图解展示 4.代码实现 5.复杂度分析 堆排序 1.算法描述 2.动图展示 3.图解展示 4.堆的一些基本性质 5.堆的构造 6.代码实现 7.复杂度分析 选择排序 1.算法描述 2.动图展示 3.图解展示 4.代码实现 5.复杂度 快速排序 1.算法简介 2.动图展

  • java中几种常见的排序算法总结

    java中几种常见的排序算法总结

    目录 本节目标: [插入排序] [优化版] [希尔排序] [选择排序] [堆排序]  [冒泡排序] 介绍一个冒泡排序的优化方法:  [快速排序] [归并排序] [正文] [代码简介:]  [排序总结] 本节目标: :分析常见的比较排序算法基本原理及实现 :分析排序算法的性能分析 :分析Java中常用排序方法 1 排序 排序,就是使一串记录,按照其中某个或某些关键字的大小,递增或递减排列的操作. 平时的上下文中,提到排序 通常指排升序. 2 稳定性 两个相同的数据,如果经过排序后,排序算法能保证其

  • C语言面试常见考点排序总结

    C语言面试常见考点排序总结

    排序算法有两块比较重要的知识点 内存消耗 :算法的内存消耗可以通过空间复杂度来衡量,排序算法也不例外.不过,针对排序算法的空间复杂度,有一个概念是原地排序.原地排序算法是指空间复杂度是O(1)的排序算法.其中冒泡排序,插入排序.选择排序都属于原地排序算法 稳定性:针对排序算法,我们还有一个衡量指标是稳定性.这个概念是说,如果待排序的序列中存在值相等的元素,经过排序之后,相等元素之间原有的先后顺序不变. 例如我们有一组数据 2 9 3 4 8 3 按照从小到大的排序是 2 3 3 4 8 9,经过

  • C语言超详细讲解排序算法上篇

    C语言超详细讲解排序算法上篇

    目录 1.直接插入排序 2.希尔排序(缩小增量排序) 3.直接选择排序 4.堆排序 进入正式内容之前,我们先了解下初阶常见的排序分类 :我们今天讲前四个! 1.直接插入排序 基本思想:当插入第i(i>=1)个元素时,前面的array[0],array[1],…,array[i-1]已经排好序,此时用array[i]的排 序码与array[i-1],array[i-2],…的排序码顺序进行比较,找到插入位置即将array[i]插入,原来位置上的元素顺序后移! 直接插入排序的特性总结: 1. 元素集

  • C语言超详细梳理排序算法的使用

    C语言超详细梳理排序算法的使用

    目录 排序的概念及其运用 排序的概念 排序运用 插入排序 直接插入排序 希尔排序 选择排序 直接选择排序 堆排序 交换排序之冒泡排序 总结 排序的概念及其运用 排序的概念 排序:所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作. 稳定性:假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次 序保持不变,即在原序列中,r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排 序算法

  • Go语言实现常用排序算法的示例代码

    Go语言实现常用排序算法的示例代码

    目录 冒泡排序 快速排序 选择排序 插入排序 排序算法是在生活中随处可见,也是算法基础,因为其实现代码较短,应用较常见.所以在面试中经常会问到排序算法及其相关的问题,可以说是每个程序员都必须得掌握的了.为了方便大家学习,花了一天的时间用Go语言实现一下常用的算法且整理了一下,如有需要可以参考. 冒泡排序 思路:从前往后对相邻的两个元素依次进行比较,让较大的数往下沉,较小的网上冒,即每当两个相邻的元素比较后发现他们的排序要求相反时,就将它们互换. 时间复杂度:O(N^2) 空间复杂度:O(1) f

  • python 常见的排序算法实现汇总

    排序分为两类,比较类排序和非比较类排序,比较类排序通过比较来决定元素间的相对次序,其时间复杂度不能突破O(nlogn):非比较类排序可以突破基于比较排序的时间下界,缺点就是一般只能用于整型相关的数据类型,需要辅助的额外空间. 要求能够手写时间复杂度位O(nlogn)的排序算法:快速排序.归并排序.堆排序 1.冒泡排序 思想:相邻的两个数字进行比较,大的向下沉,最后一个元素是最大的.列表右边先有序. 时间复杂度$O(n^2)$,原地排序,稳定的 def bubble_sort(li:list):

  • C语言实现九大排序算法的实例代码

    C语言实现九大排序算法的实例代码

    直接插入排序 将数组分为两个部分,一个是有序部分,一个是无序部分.从无序部分中依次取出元素插入到有序部分中.过程就是遍历有序部分,实现起来比较简单. #include <stdio.h> void insertion_sort(int arr[], int array_length) { for (int i = 0; i < array_length; ++i) { int data = arr[i]; int j = 0; while (arr[j] < arr[i]) { j

随机推荐