您的位置:首页 > 编程语言 > Go语言

go语言实现常见排序算法

2019-09-29 15:01 113 查看

排序算法是一种采用列表或数组并以特定顺序对其元素进行重新排序的算法。

排序是计算机的核心内容,算法是程序的灵魂,而排序算法则是一种最基本的算法。

本文介绍7种排序算法:冒泡排序、简单选择排序、直接插入排序、希尔排序、堆排序、归并排序以及快速排序。

一、冒泡排序

  • 简介

    冒泡排序是一种简单的排序算法。它重复的走访要排序的数列,一次 比较两个元素,如果它们的顺序有误则交换它们。如果某一次重复未 进行任何交换,则说明该数列已经排序完成。这个算法名字的由来是 因为越小的元素会经由交换慢慢浮到数列的顶端。

  • 算法描述

      比较相邻的元素。如果第一个比第二个大,就交换它们两个;
    1. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素将会是最大的数;
    2. 针对所有的元素重复以上的步骤,除了最后一个;
    3. 重复步骤1~3,直到排序完成。
  • 代码实现

package main

import "fmt"

func main() {
s := []int{5, -3, 4, -2, 1, -5, 3, -4, 2, -1, 0}
bubbleSort(s)
fmt.Println(s)
}

func bubbleSort(s []int) {
for i := 0; i < len(s)-1; i++ {
flag := false
for j := 0; j < len(s)-i-1; j++ {
if s[j] > s[j+1] {
s[j], s[j+1] = s[j+1], s[j]
flag = true
}
}
if !flag {
break
}
}
}

结果如下

  • 算法复杂度

时间复杂度(平均) 时间复杂度(最坏) 时间复杂度(最好) 空间复杂度 稳定性
O(n2) O(n2) O(n) O(1) 稳定
  • 相关概念

      稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面;
    1. 不稳定:如果a原本在b的前面,而a=b,排序之后 a 可能会出现在 b 的后面;
    2. 时间复杂度:对排序数据的总的操作次数。反映当n变化时,操作次数呈现什么规律;
    3. 空间复杂度:是指算法在计算机内执行时所需存储空间的度量,它也是数据规模n的函数。

二、简单选择排序

  • 简介

    选择排序是一种简单直观的排序方法。它的工作原理:首先在原始 数列中找到最小(大)元素,存放在排序数列的起始位置,然后再从 剩余未排序数列中找到最小(大)元素放到排序数列的尾部。以此类 推,直到所有元素排序完成。

  • 算法描述

    n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。

      初始状态:无序区为R[1..n],有序区为空;
    1. 第i趟排序(i=1,2,3…n-1)开始时,当前有序区和无序区分别为R[1..i-1]和R(i..n)。该趟排序从当前无序区中选出索引为k的最小的元素R[k],将它与无序区的索引为i的元素R[i]交换,使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区;
    2. n-1趟结束,数组有序化了。
  • 代码实现

package main

import "fmt"

func main() {
s := []int{5, -3, 4, -2, 1, -5, 3, -4, 2, -1, 0}
selectSort(s)
fmt.Println(s)
}

// 在算法实现时,每一趟确定最小元素的时候
// 会通过不断地比较交换来使得首位置为当前
// 最小,交换是个比较耗时的操作。其实我们
// 很容易发现,在还未完全确定当前最小元素
// 之前,这些交换都是无意义的。我们可以通
// 过设置一个变量min,每一次比较仅存储较小
// 元素的数组下标,当轮循环结束之后,那这个
// 变量存储的就是当前最小元素的下标,此时再
// 执行交换操作即可。
func selectSort(s []int) {
for i := 0; i < len(s)-1; i++ {
// 每一趟的开始把首元素的下标作为最小元素的下标
min := i
for j := i + 1; j < len(s); j++ {
if s[min] > s[j] {
min = j
}
}
if min != i {
s[i], s[min] = s[min], s[i]
}
}
}
  • 算法复杂度

时间复杂度(平均) 时间复杂度(最坏) 时间复杂度(最好) 空间复杂度 稳定性
O(n2) O(n2) O(n2) O(1) 不稳定
  • 算法分析

    表现最稳定的排序算法之一,因为无论什么数据进去都是O(n2)的时间复杂度,所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲,选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

三、直接插入排序

  • 简介

    插入排序也是一种简单直观的排序方法。它的工作原理是 通过构建有序数列,对于未排序数据,在已排序数列中从 后向前扫描,找到相应位置并插入。

  • 算法描述

    一般来说,插入排序都采用in-place在数组上实现。具体算法描述如下:

      从第一个元素开始,该元素可以认为已经被排序;
    1. 取出下一个元素,在已经排序的元素序列中从后向前扫描;
    2. 如果该元素(已排序)大于新元素,将该元素移到下一位置;
    3. 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;
    4. 将新元素插入到该位置后;
    5. 重复步骤2~5。
  • 代码实现

package main

import "fmt"

func main() {
s := []int{5, -3, 4, -2, 1, -5, 3, -4, 2, -1, 0}
insertSort(s)
fmt.Println(s)
}

func insertSort(s []int) {
for i := 1; i < len(s); i++ {
j := i
if s[i] < s[i-1] {
for j > 0 && s[j] < s[j-1] {
s[j], s[j-1] = s[j-1], s[j]
j--
}
}
}
}
  • 算法复杂度

时间复杂度(平均) 时间复杂度(最坏) 时间复杂度(最好) 空间复杂度 稳定性
O(n2) O(n2) O(n) O(1) 稳定
  • 算法分析

    插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。

四、希尔排序

  • 简介

    1959年Shell发明,第一个突破O(n2)的排序算法,是简单插入排序的改进版。它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

  • 算法描述

    先将整个待排序的记录序列分割成为若干子序列,再分别进行直接插入排序,具体算法描述:

      选择一个增量序列t1,t2,…,ti,…,tj,…,tk,其中ti>tj,tk=1;
    1. 按增量序列个数k,对序列进行k 趟排序;
    2. 每趟排序,根据对应的增量ti,将待排序列分割成若干长度为m 的子序列,分别对各子表进行直接插入排序。仅增量因子为1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。
  • 代码实现

package main

import "fmt"

func main() {
s := []int{5, -3, 4, -2, 1, -5, 3, -4, 2, -1, 0}
shellSort(s)
fmt.Println(s)
}

func shellSort(s []int) {
// 增量gap,并逐步缩小增量
for gap := len(s)/2; gap > 0; gap /= 2 {
// 从gap开始,逐步对其所在组进行直接插入排序
for i := gap; i < len(s); i++ {
j := i
for j - gap >= 0 && s[j] < s[j-gap] {
s[j], s[j-gap] = s[j-gap], s[j]
j -= gap
}
}
}
}
  • 算法复杂度

时间复杂度(平均) 时间复杂度(最坏) 时间复杂度(最好) 空间复杂度 稳定性
O(n1.3) O(n2) O(n) O(1) 不稳定
  • 算法分析

希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列,也可以动态的定义间隔序列。

五、堆排序

  • 堆的概念

堆是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象。堆可被认为是一种图的树状结构,常常被用于实现“优先队列”。

  • 堆的特性

      完全二叉树;
    1. 堆中某个节点的值总是不大于或不小于其父节点的值;
    2. 根节点最大(大堆)或最小(小堆);
    3. 如果父节点索引为i,则左子节点索引为2i+1,右子节点索引为2i+2;如果左子节点或右子节点索引为j,则父节点索引为(j-1)/2。
  • 堆排序

  • 简介

    堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。

  • 算法描述

    利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性,使得每次从无序中选择最大记录(最小记录)变得简单。其基本思想为(大顶堆):

      将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆,此堆为初始的无序区;
    1. 将堆顶元素R[1]与最后一个元素R
      交换,此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R
      ;
    2. 由于交换后新的堆顶R[1]可能违反堆的性质,因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆,然后再次将R[1]与无序区最后一个元素交换,得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1,则整个排序过程完成。

  • 操作过程

      初始化堆:将R[1..n]构造为堆;
    1. 将当前无序区的堆顶元素R[1]同该区间的最后一个记录交换,然后将新的无序区调整为新的堆。

因此对于堆排序,最重要的两个操作就是构造初始堆调整堆,其实构造初始堆事实上也是调整堆的过程,只不过构造初始堆是对所有的非叶节点都进行调整。

堆排序适合于数据量非常大的场合(百万数据)

  • 代码实现
package main

import "fmt"

func main() {
s := []int{5, -3, 4, -2, 1, -5, 3, -4, 2, -1, 0}
heapSort(s)
fmt.Println(s)
}

func heapSort(s []int) {
if len(s) == 0 {
return
}
// 1.构造初始堆
// 从最后一个非叶子节点开始,到根节点结束
for i := len(s)/2 - 1; i >= 0; i-- {
heapAdjust(s, i, len(s)-1)
}
// 2.开始堆排序
for j := len(s) - 1; j >= 0; j-- {
s[0], s[j] = s[j], s[0]
heapAdjust(s, 0, j-1)
}
}

func heapAdjust(s []int, start, end int) {
temp := s[start]
// 从主节点的左子节点开始,也即从2*start+1开始
for k := 2*start + 1; k <= end; k = 2*k + 1 {
// 取左右节点值较大的节点的索引
if k < end && s[k] < s[k+1] {
k++
}
// 如果主节点值大于左右节点的值,则调整结束
if s[k] <= temp {
break
}
// 更新主节点值
s[start] = s[k]
// 以左右节点值较大的节点为下一个主节点
start = k
}
s[start] = temp
}
  • 算法复杂度

时间复杂度(平均) 时间复杂度(最坏) 时间复杂度(最好) 空间复杂度 稳定性
O(nlogn) O(nlogn) O(nlogn) O(1) 不稳定

六、归并排序

  • 简介

    归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。

分治法将问题分(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起,即分而治之。

  • 算法描述

      把长度为n的输入序列分成两个长度为n/2的子序列;
    1. 对这两个子序列分别采用归并排序;
    2. 将两个排序好的子序列合并成一个最终的排序序列。

  • 代码实现
package main

import "fmt"

func main() {
s := []int{5, -3, 4, -2, 1, -5, 3, -4, 2, -1, 0}
mergeSort(s)
fmt.Println(s)
}

func mergeSort(s []int) {
temp := make([]int, len(s))
mSort(s, 0, len(s)-1, temp)
}

func mSort(s []int, left, right int, temp []int) {
if left >= right {
// 子序列分割完毕
return
}
mid := (left + right) / 2
mSort(s, left, mid, temp)
mSort(s, mid+1, right, temp)
// 两边的子序列都是有序的,只有当
// 左边的最大元素大于右边的最小元素
// 时才需要合并
if s[mid] > s[mid+1] {
merge(s, left, mid, right, temp)
}
}

func merge(s []int, left, mid, right int, temp []int) {
i := left    // 左子序列初始索引
j := mid + 1 // 右子序列初始索引
t := 0       // temp的初始索引
for i <= mid && j <= right {
if s[i] < s[j] {
temp[t] = s[i]
i++
} else {
temp[t] = s[j]
j++
}
t++
}
// 将左序列剩余元素填充到temp中
for i <= mid {
temp[t] = s[i]
i++
t++
}
// 将右序列剩余元素填充到temp中
for j <= right {
temp[t] = s[j]
j++
t++
}
// 将temp中的元素全部拷贝到原数列中
t = 0
for left <= right {
s[left] = temp[t]
left++
t++
}
}
  • 算法复杂度

时间复杂度(平均) 时间复杂度(最坏) 时间复杂度(最好) 空间复杂度 稳定性
O(nlogn) O(nlogn) O(nlogn) O(n) 稳定
  • 算法分析

归并排序是一种稳定的排序方法。和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是O(nlogn)的时间复杂度。代价是需要额外的内存空间。

七、快速排序

  • 简介

    快速排序的基本思想:通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。

快速排序是一个就地排序,分而治之,大规模递归的算法。从本质上来说,它是归并排序的就地版本。

  • 算法描述

    快速排序使用分治法来把一个串(list)分为两个子串(sub-lists)。具体算法描述如下:

      从数列中挑出一个元素,称为 “基准”(pivot);
    1. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;
    2. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。

  • 操作过程

      如果不多于1个数据,直接返回。
    1. 一般选择序列最左边的值作为支点数据。
    2. 将序列分成2部分,一部分都大于支点数据,另外一部分都小于支点数据。
    3. 对两边利用递归排序数列。

  • 代码实现
package main

import "fmt"

func main() {
s := []int{5, -3, 4, -2, 1, -5, 3, -4, 2, -1, 0}
quickSort(s, 0, len(s)-1)
fmt.Println(s)
}

func quickSort(s []int, left, right int) {
if left >= right {
return
}
// 调整基准的索引
i := quickAdjust(s, left, right)
// 调整左边的序列
quickSort(s, left, i-1)
// 调整右边的序列
quickSort(s, i+1, right)
}

// 返回调整后基准数的位置,基准数取s[left]
func quickAdjust(s []int, left, right int) int {
i, j := left, right
for i < j {
// 从右向左找小于基准的数
for i < j && s[j] >= s[left] {
j--
}
// 从左向右找大于基准的数
for i < j && s[i] <= s[left] {
i++
}
// 交换
if i < j {
s[i], s[j] = s[j], s[i]
}
}
// 调整基准的位置
s[left], s[i] = s[i], s[left]
return i
}
  • 算法复杂度

时间复杂度(平均) 时间复杂度(最坏) 时间复杂度(最好) 空间复杂度 稳定性
O(nlogn) O(n2) O(nlogn) O(nlogn) 不稳定
  • 算法分析

快速排序比大部分排序算法都要快。尽管我们可以在某些特殊的情况下写出比快速排序快的算法,但是就通常情况而言,没有比它更快的了。快速排序是递归的,对于内存非常有限的机器来说,它不是一个好的选择。

参考文章

内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: