排序算法（go实现）

谬了个大也

已于 2022-01-23 15:12:00 修改

阅读量278

点赞数

分类专栏：算法文章标签：排序算法 golang 算法

于 2022-01-20 14:55:40 首次发布

本文链接：https://blog.csdn.net/my_miuye/article/details/122601752

版权

算法专栏收录该内容

50 篇文章 0 订阅

订阅专栏

1、冒泡排序

1.1 算法描述

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

1.2 代码实现

func sort(arr []int) {
	length:=len(arr)
	for i:=0;i<length;i++{
		for j:=0;j<length-i-1;j++{   //最后的元素是最大的数
			if arr[j+1]<arr[j]{
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
	}
}

1.3 时间空间复杂度

时间：
平均O(n²) 　最差O(n²) 　最好O(n)

空间：
O(1)

2、选择排序

它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1…n]，有序区为空；
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n-1趟结束，数组有序化了。

2.2 代码实现

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

2.3 时间空间复杂度

时间：
平均O(n²) 　最差O(n²) 　最好O(n²)

空间：
O(1)

3、插入排序

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3.1 算法描述

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

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤2~5。

3.2 代码实现

func sort(arr []int){
	length:=len(arr)
	for i:=1;i<length;i++{
		j:=i-1
		tmp:=arr[i]
		for j>=0 && arr[j]>tmp {    //找到tmp在已排序元素中的位置
			arr[j+1]=arr[j]
			j--
		}
		arr[j+1]=tmp
	}
}

3.3 时间空间复杂度

时间：
平均O(n²) 　最差O(n²) 　最好O(n)

空间：
O(1)

4、快速排序

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

4.1 算法描述

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

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

4.2 代码实现

我们可以通过双指针在O(n)的时间复杂度内获取合适的 j

我们设立两个指针 i 和 j，同时设置一个标志值 arr[low]，一般来说，标志值取数组第一个元素

当 arr[i] < arr[low]时，指针 i 从左至右一直扫描
当 arr[j] > arr[low]时，指针 j 从右至左一直扫描
交换 arr[i]和 a[j]的元素
当 i < j 时重复以上步骤

上述算法结束之后，j 所在的位置即为我们寻找的 j

func sort(arr []int,left int,right int)  {
	if left>=right{
		return
	}
	middle:=partition(arr,left,right)
	sort(arr,0,middle-1)
	sort(arr,middle+1,right)

}

func partition(arr []int,left int,right int)  int {
	i:=left+1  //左指针
	j:=right   //右指针
	
	//默认与arr[left]为分割，最终比arr[left]小的在其左边，比arr[left]大的在其右边
	for true{
		for i<right {
			if arr[i]>arr[left] {  //找比arr[left]大的值，找不到就右移接着找
				break
			}
			i++
		}
		for j>left {   
			if  arr[j]<arr[left] {  //找比arr[left]小的值，找不到就左移接着找
				break
			}
			j--
		}
		//没有找到
		if i>=j {
			break
		}
		//找到了，进行交换
		arr[i], arr[j] = arr[j], arr[i]
	}
	//此时，arr[left]<arr[j]<arr[i]
	arr[left], arr[j] = arr[j], arr[left]
	return j
}

4.3 时间空间复杂度

时间：
平均O(nlog₂n) 　最差O(n²) 　最好O(nlog₂n)

空间：
O(1)

5、堆排序

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

5.1 算法描述

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

5.2 代码实现

go中提供了 container/heap 来实现堆，堆中元素的类型需要实现 heap.Interface 这个接口。

最大堆：func (h IntHeap) Less(i, j int) bool { return h[i] > h[j] }
最小堆：func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }

type IntHeap []int

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] > h[j] }
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *IntHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}
func (h *IntHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}


func main()  {
	h := &IntHeap{3, 1, 2, 5}
	heap.Init(h)
  heap.Push(h, 4)
	for h.Len() > 0 {
		fmt.Printf("%d ", heap.Pop(h))
	}
}