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

目录
  • 冒泡排序
  • 快速排序
  • 选择排序
  • 插入排序

排序算法是在生活中随处可见,也是算法基础,因为其实现代码较短,应用较常见。所以在面试中经常会问到排序算法及其相关的问题,可以说是每个程序员都必须得掌握的了。为了方便大家学习,花了一天的时间用Go语言实现一下常用的算法且整理了一下,如有需要可以参考。

冒泡排序

思路:从前往后对相邻的两个元素依次进行比较,让较大的数往下沉,较小的网上冒,即每当两个相邻的元素比较后发现他们的排序要求相反时,就将它们互换。

时间复杂度:O(N^2)

空间复杂度:O(1)

func main() {
	fmt.Println(bubbleSort([]int{2, 4, 1, 6, 3}))
}

func bubbleSort(list []int) []int {
	lenth := len(list)
	for i := 0; i <= lenth; i++ {//循环对比的轮数
		exchange := false
		for j := 1; j < lenth-i; j++ {//当前轮相邻元素循环对比
			if list[j-1] > list[j]{//如果前边的大于后边的
				list[j-1], list[j] = list[j], list[j-1]//交换数据
				exchange = true
			}
		}
		if !exchange {
			break
		}
	}
	return list
}

快速排序

思路:以一个基准数将数组拆分为两组,一边大于这个数,一边小于这个数,再最左右两个组重复这个过程,直到各个区域只有一个数。

时间复杂度:O(nlogn)

空间复杂度:O(1)

func quickSort(list []int) []int {
	length := len(list)
	if length <= 1 {
		return list
	}
	//基准值
	base := list[0]
    left := make([]int, 0)
	right := make([]int, 0)
	for i := 1; i < length; i++ {
		if list[i]  > base {
			right  = append(right, list[i])
		} else {
			left = append(left, list[i])
		}
	}
	left, right  = quickSort(left), quickSort(right)
	return append(append(left, base),right...)
}

选择排序

思路:首先找到数组中的最小元素,然后将这个最小元素和数组的第一个元素交换位置,如果第一个元素就是最小元素,就和自己交换位置;再次,在剩下的元素中找到最小元素和数组中的第二个元素交换位置,如此往复,直到将整个数组排序,一句话总结就是,不断在剩余元素中找最小元素。

时间复杂度:O(n^2)

空间复杂度:O(1)

func selectSort(list []int) []int {
	length := len(list)

	for i := 0; i < length; i++ {
		minIndex := i
		//每次循环找出i+1到最后一个元素区间的最小值,然后当前元素和当前最小值比较
		for j := i + 1; j < length; j++ {
			if list[j] < list[minIndex] {
				minIndex = j
			}
		}
		if i != minIndex {
			list[i], list[minIndex] = list[minIndex], list[i]
		}
	}
	return list
}

插入排序

思路:与选择排序一样,当前索引左边的所有元素都是有序的,但是他们的最终位置还不确定,为了给更小的元素腾出空间,他们可能会被移动,但是当索引到达数组的末端,数组排序就完成了。

时间复杂度:O(N^2)

空间复杂度:O(1)

func insertSort(list []int) []int {
	length := len(list)
	for i := 0; i < length; i++ {
		for j := i; j > 0; j-- {
			if list[j] > list[j-1] {
				break
			}
			list[j], list[j-1] = list[j-1], list[j]
		}
	}
	return list
}

排序思路算法几乎一样。 暂时就介绍这几种常用的也是面试中经常问道的排序算法。

到此这篇关于Go语言实现常用排序算法的示例代码的文章就介绍到这了,更多相关Go语言排序算法内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

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

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

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

    目录 前言 五种基础排序算法对比 1.冒泡排序 2.选择排序 3.插入排序 4.快速排序 前言 现在的面试真的是越来越卷了,算法已经成为了面试过程中必不可少的一个环节,你如果想进稍微好一点的公司,「算法是必不可少的一个环节」.那么如何学习算法呢?很多同学的第一反应肯定是去letcode上刷题,首先我并不反对刷题的方式,但是对于一个没有专门学习过算法的同学来说,刷题大部分是没什么思路的,花一个多小时暴力破解一道题意义也不大,事后看看别人比较好的解法大概率也记不住,所以我觉得「专门针对算法进行一些简

  • Golang实现拓扑排序(DFS算法版)

    问题描述:有一串数字1到5,按照下面的关于顺序的要求,重新排列并打印出来.要求如下:2在5前出现,3在2前出现,4在1前出现,1在3前出现. 该问题是一个非常典型的拓扑排序的问题,一般解决拓扑排序的方案是采用DFS-深度优先算法,对于DFS算法我的浅薄理解就是递归,因拓扑排序问题本身会有一些前置条件(本文不过多介绍拓扑算法的定义),所以解决该问题就有了以下思路. 先将排序要求声明成map(把map的key,value看作对顺序的要求,key应在value前出现),然后遍历1-5这几个数,将每次遍

  • 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

  • go实现冒泡排序算法

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

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

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

  • C语言实现经典排序算法的示例代码

    目录 一.冒泡排序 1.原理 2.实现 3.算法分析 二.选择排序 1.原理 2.实现 3.算法分析 三.插入排序 1.原理 2.实现 3.算法分析 四.希尔排序 1.原理 2.实现 3.算法分析 总结 一.冒泡排序 1.原理 从数组的头开始不断比较相邻两个数的大小,不断将较大的数右移,一个循环后,最大数移至最后一位,无序数组规模减一.不断重复前面动作,知道数组完全有序. 2.实现 void swap(int* a, int* b) { int temp = *a; *a = *b; *b =

  • Java实现8种排序算法的示例代码

    冒泡排序 O(n2) 两个数比较大小,较大的数下沉,较小的数冒起来. public static void bubbleSort(int[] a) { //临时变量 int temp; //i是循环次数,也是冒泡的结果位置下标,5个数组循环5次 for (int i = 0; i < a.length; i++) { //从最后向前面两两对比,j是比较中下标大的值 for (int j = a.length - 1; j > i; j--) { //让小的数字排在前面 if (a[j] <

  • python实现经典排序算法的示例代码

    以下排序算法最终结果都默认为升序排列,实现简单,没有考虑特殊情况,实现仅表达了算法的基本思想. 冒泡排序 内层循环中相邻的元素被依次比较,内层循环第一次结束后会将最大的元素移到序列最右边,第二次结束后会将次大的元素移到最大元素的左边,每次内层循环结束都会将一个元素排好序. def bubble_sort(arr): length = len(arr) for i in range(length): for j in range(length - i - 1): if arr[j] > arr[j

  • C语言实现可排序通讯录的示例代码

    目录 1.目的 2.分部流程 1.初始化通讯录 2.添加联系人 3.判断联系人是否存在 4.判断通讯录是否已满 5.判断通讯录是否为空 6.通讯录扩容 7.核心函数 8.查找联系人 9.修改联系人 10.清空通讯录 11.删除联系人 12.显示通讯录 13.比较联系人 14.通讯录排序 3.总代码展示 1.目的 写一个实用型通讯录,它有如下功能: 显示目录 void ShowMenu() { printf("#######################\n"); printf(&qu

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

    目录 1.冒泡排序 2.选择排序 3.快速排序 4.插入排序 补充 1.冒泡排序 两两相比,每循环一轮就不用再比较最后一个元素了,因为最后一个元素已经是最大或者最小. function maopaoSort ($list) { $len = count($list); for ($i = 0; $i < $len - 1; $i++) { for ($j = 0; $j < $len - $i - 1; $j++) { if ($list[$j] > $list[$j + 1]) { $

  • Java实现基本排序算法的示例代码

    目录 1. 概述 2. 插入排序 2.1 直接插入排序 2.2 希尔排序(缩小增量排序) 3. 选择排序 3.1 直接选择排序 3.2 堆排序 4. 交换排序 4.1 冒泡排序 4.2 快速排序 5. 归并排序 6. 计数排序(非比较类型的排序) 7. 排序算法总结 1. 概述 排序概念:就是将一串记录按照其中某个或某些关键字的大小,递增或递减的排列起来的操作. 稳定性:通俗的将就是数据元素不发生有间隔的交换,例如: 内部排序:数据元素全部放在内存中的排序 外部排序:数据元素太多不能一次加载到内

  • Java实现拓扑排序算法的示例代码

    目录 拓扑排序原理 1.点睛 2.拓扑排序 3.算法步骤 4.图解 拓扑排序算法实现 1.拓扑图 2.实现代码 3.测试 拓扑排序原理 1.点睛 一个无环的有向图被称为有向无环图.有向无环图是描述一个工程.计划.生产.系统等流程的有效工具.一个大工程可分为若干子工程(活动),活动之间通常有一定的约束,例如先做什么活动,有什么活动完成后才可以开始下一个活动. 用节点表示活动,用弧表示活动之间的优先关系的有向图,被称为 AOV 网. 在 AOV 网中,若从节点 i 到节点 j 存在一条有向路径,则称

  • 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+

随机推荐