8大排序算法详解————转载

转载自微信公众号：LeetCode力扣，原文文章地址：点击这里

外加**个人理解和优化补充**：

一、冒泡排序

冒泡排序是一种简单的排序算法。它重复地走访要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作就是重复地进行直到不需要再进行交换为止，也就是说该数列已经排序完成。这个算法的名字由来就是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

算法描述

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

算法排序流程

算法实现

void bubbleSort(int a[],int len){
	int i=0,j=0;
	if(len<=0) return;
	for(i=0;i<len-1;i++){
		for(j=0;j<len-i-1;j++){
			if(a[j]>a[j+1])//稳定
			{
				int temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp;
			}
		}
	}

}

//改进算法
void bubbleSort(int a[],int len){
	if(len<=0) return;
	int i=0,j=0,flag = 0;//交换标志位
	for(i=0;i<len-1;i++){
		for(j=0;j<len-i-1;j++){
			if(a[j]>a[j+1])//稳定
			{
				int temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp;
				flag = 1;
			}
		}
		if(0==flag) return;
		else flag = 0;
	}
}

算法分析

• 最佳情况：O(n)
• 最差情况：O(n^2)
• 平均时间复杂度：O(n^2)
• 空间复杂度为O(1)
• 稳定排序算法

稳定算法：（https://baike.baidu.com/item/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95%E7%A8%B3%E5%AE%9A%E6%80%A7/9763250?fr=aladdin）假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的

二、选择排序

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

算法描述

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趟结束，数组有序化。

算法排序流程

算法实现

void selectSort(int a[],int len)
{
	if(len<=0) return;
	for(int i=0;i<len-1;i++){
		int min = a[i];
		int cursor = i;
		for(int j=i+1;j<len;j++){
			if(a[j]<min){
				min = a[j];
				cursor = j;
			}
		}
		//找到最小的交换
		int temp = a[i];
		a[i] = min;
		a[cursor] = a[i];
	}
}

算法分析

• 最佳情况：O(n^2)
• 最差情况：O(n^2)
• 平均时间复杂度：O(n^2)
• 空间复杂度：O(1)
• 不稳定排序算法

三、插入排序

插入排序算法是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描的过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

算法描述

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

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

算法排序流程

算法实现

//插入排序
void insertSort(int a[],int len){
	if(a == NULL) return;
	for(int i=0;i<len-1;i++){
		int cur = a[j+1];//存储当前值
		int k = i;
		while(k>=0&&a[k]>cur){ //边界问题
			a[k+1] = a[k];
			k--;
		}//k表示待插入位置的前一个位置
		a[k+1] = cur;
	}
}

算法分析

• 最佳情况：O(n)
• 最坏情况：O(n^2)
• 平均时间复杂度：O(n^2)
• 空间复杂度：O(1)
• 稳定排序算法

四、希尔排序

希尔排序是希尔于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n^2)的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
希尔排序是把记录按一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组所包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

算法描述

在此我们选择希尔排序增量为gap = length / 2，缩小增量继续以gap = gap / 2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2,…,1},称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。

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

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

算法排序流程

算法实现

//三重循环--采用二分间隔
void ShellSort(int a[],int len){
	if(a == nullptr) return;
	int gap = len/2;
	while(gap>0){
	for(int i=gap;i<len;i = i+gap){//注意这里为了防止越界采用了不同的初始化
			int cur = a[i];
			int preIndex = i-gap;
			while(preIndex>=0&&a[preIndex]>cur){
				a[preIndex+gap] = a[preIndex];
				preIndex -= gap;
			}
			a[preIndex+gap] = cur;
		}
		gap /=2;
	}

}

算法分析

• 最佳情况：O(nlogn)
• 最坏情况：O(nlogn)
• 平均时间复杂度：O(nlogn)
• 空间复杂度：O(1)
• 不稳定排序算法

五、归并排序

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn)的时间复杂度。代价是需要额外的内存空间。
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使得每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

算法描述

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

算法排序流程

算法实现

//归并排序--这里选择2-路归并排序，涉及到数据的合并--递归
void Merge(int a[],int left,int right,int len){//合并了left和right闭区间的数组
	//暂时不考虑边界问题
	int begin1 = left;
	int end1 = left+(right-left)/2
	int begin2 = end1 +1;
	int end2 = right;
	//开始合并--需要移动的空间存储已经排好序的
	int *arrayTemp = new int[right-left+1];
	int k=0;
	while(begin1<=end1&&begin2<=end2){
		if(a[begin1]<=a[begin2])//合并两个数组两个数数组进行比较
			arrayTemp [k++] = a[begin1++];
		else arrayTemp [k++] = a[begin2++];
	}
	//检查哪部分数组先结束
	while(begin1<= end1) arrayTemp [k++] = a[begin1++];
	while(begin2<=endl2) arrayTemp [k++] = a[begin2++];
	//数组拷贝
	for(int p=0;p<right-left+1;p++){
		a[left+p] = arrayTemp[p];
	}
	delete [] arrayTemp;
}

//调用和递归
void MergeSort(int a[],int left,int right){
	if(left<right){//递归条件--只有一个元素的时候就结束递归了
		int mid = left+(right-left)/2;
		MergeSort(a,left,mid);
		MergerSore(a,mid+1,right);
		Merge(a,left,right);
//典型的递归思想，递归后再执行的操作，思考方向是这样的，自顶向下：问题的全部分为子问题和最后一步操作了，前提是子问题已经解决，那么我执行最后一步操作就行了；
还有一种思路是，我执行了一步操作，发现只剩下子问题了，那么就是在递归前要执行的操作。		
	}

}

算法分析

• 最佳情况：O(n)
• 最坏情况：O(nlogn)
• 平均时间复杂度：O(nlogn)
• 空间复杂度：O(n)
• 稳定排序算法

• 六、快速排序

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

  算法描述

  快速排序适用分治法来把一个串分为两个子串。具体算法描述如下：

  • 从数列中跳出一个元素，称为“基准”
  • 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区操作；
  • 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

  算法排序流程

  

  算法实现

  void swap(int *a, int *b){
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
    return;
  }
  
  void quicksort(int arr[], int maxlen, int begin, int end){
    int i,j;
    if(begin < end){
      i = begin + 1;
      j = end;
      while(i < j){
        if(arr[i] > arr[j]){
          swap(&arr[i], &arr[j]);
          j--;
        }
        else{
          i++;
        }
      }
      if(arr[i] >= arr[j]){
        i--;
      }
      swap(&arr[i], &arr[j]);
      quicksort(arr, maxlen, begin, i);
      quicksort(arr, maxlen, j, end);
    }
  }
  算法分析
  最佳情况：O(nlogn)
  最坏情况：O(n^2)
  平均时间复杂度：O(nlogn)
  空间复杂度：O(nlogn)
  不稳定排序算法
  七、堆排序
  
  堆排序是指利用堆这种数据结构所涉及的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足下面的性质：子结点的键值或索引总是小于（或者大于）它的父结点。
  算法描述
  将初始待排序关键字序列(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,则整个排序过程完成。
  算法排序流程
  
  
  算法注意
  堆排序的重点为构造堆：
  这里采用的自底向上的思路构造堆
  
  算法实现
  ```cpp
  //自底向上构建最大堆
  //数组和堆的对应关系：根节点为数组头；广度优先排列；
  //可以推导的性质：下标为i的孩子结点为[2i+1]和[2i+2]；
  //下标p的父亲结点为(p-1)/2;最后一个非叶子结点下标为n/2-1
  //调整堆
  void AdjustHeap(int a[],int parent,int len)
  {
  	int child,temp;
  	//不断判断子树要全部符合堆的性质
  	for(;2*parent+1