【经典排序算法】（一）--- 比较类排序（冒泡排序，快速排序 ，简单插入排序，希尔排序，简单选择排序，堆排序，归并排序）

概述

通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。

算法复杂度

排序方法	时间复杂度（平均）	时间复杂度（最坏）	时间复杂度（最好）	空间复杂度	稳定性
冒泡排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
快速排序	O(nlog2n)	O(n^2)	O(nlog2n)	O(n)	不稳定
插入排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
希尔排序	O(n^1.3)	O(n^2)	O(n)	O(1)	不稳定
选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
堆排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(1)	不稳定
归并排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(n)	稳定

相关概念

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

一. 交换排序

1. 冒泡排序

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

• 算法描述：

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

重复步骤1~3，直到排序完成。

• 代码演示：

#include <iostream>
using namespace std;

int bubbleSort(int arr[],int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		for (int j = 0; j < n - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	return 0;
}

int main()
{
	int arr[1000];
	int n;
	cout << "请输入数组中元素的个数：";
	cin >> n;
	cout << "请输入元素: " << endl;
	for (int i = 0; i < n; i++)
	{
		cin >> arr[i];
	}
	cout << "排序前：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	bubbleSort(arr, n);
	cout << "排序后：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	return 0;
}

运行结果如下：

当然，我们可以再优化一下冒泡排序：

int bubbleSort(int arr[],int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		bool flag = true;
		for (int j = 0; j < n - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				flag = false;
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
		if (flag)
		{
			break;
		}
	}
	return 0;
}

这样，当后面已经排序好了的情况下，我们就不需要再去遍历后面的元素了。

2. 快速排序

• 介绍：
  快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
• 算法描述：
  快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

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

• 代码演示：

#include <iostream>
using namespace std;

int swap(int *a, int *b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
	return 0;
}

int quicksort(int arr[], int left, int right)
{
	if (left >= right)
	{
		return 0;
	}
	int i = left;
	int j = right + 1;
	int key =arr[left];//设置基准值
	while (true)
	{
		//从左向右找比key大的值
		while (arr[++i] < key && i != right);
		//从右向左找比key小的值
		while (arr[--j] > key && j != left);
		if (i >= j)
		{
			break;
		}
		//交换ij对应的值
		swap(&arr[i], &arr[j]);
	}
	//将基准值（中枢值）与j所对应的值交换,因为arr[J]是小于基准中下标最大的
	swap(&arr[left], &arr[j]);
	quicksort(arr, left, j - 1);
	quicksort(arr, j + 1, right);
	return 0;
}

int main()
{
	int arr[1000];
	int n;
	cout << "请输入数组中元素的个数：";
	cin >> n;
	cout << "请输入元素: " << endl;
	for (int i = 0; i < n; i++)
	{
		cin >> arr[i];
	}
	cout << "排序前：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	quicksort(arr, 0, n - 1);
	cout << "排序后：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	return 0;
}

运行结果如下：

虽然我们实现了快速排序，但是却存在两个问题：

1. 如果出现最坏的情况（上面我是将第一个设为基准的，如果前面的几个元素有序，那么我上面这个方法的时间复杂度就会很高。）
2. 由于快速排序一般是由递归实现的，如果待排序的规模较小，递归的副作用就会凸显出来，效果会变得很差.

解决以上问题的方法：

1. 一种比较好的方法是将arr[left],arr[right],arr[(left+right)/2]三者关键字的中值作为基准，这样有可能避免在基本有序的序列中进行快速排序时间复杂度出现最坏情况的问题。
2. 当规模较小时就不需要递归了，直接调用简单插入排序就能解决这个问题。

代码演示：

#include <iostream>
#include <algorithm>
using namespace std;
//交换
int swap(int *a, int *b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
	return 0;
}
//简单插入排序
int insertsort(int arr[], int n)
{
	int temp, i, j;
	for (i = 1; i < n; i++)
	{
		temp = arr[i];
		for (j = i; j > 0 && arr[j - 1] > temp; j--)
		{
			arr[j] = arr[j - 1];
		}
		arr[j] = temp;
	}
	return 0;
}
//获得基准值
int median3(int arr[], int left, int right)
{
	int center = (left + right) / 2;
	if (arr[left] > arr[center])
	{
		swap(&arr[left], &arr[center]);
	}
	if (arr[left] > arr[right])
	{
		swap(&arr[left], &arr[right]);
	}
	if (arr[center] > arr[right])
	{
		swap(&arr[center], &arr[right]);
	}
	//此时arr[left]<arr[center]<arr[right]
	swap(&arr[center], &arr[right - 1]);//已知arr[right]>arr[center]
	return arr[right - 1];//只需考虑arr[left+1]到arr[right-2]的值，所以返回arr[right-1]
}
//快排
int quicksort(int arr[], int left, int right)
{
	int key, i, j;
	if (right - left > 3)//当元素较多时调用快速排序
	{
		key = median3(arr, left, right);//选择基准
		i = left;
		j = right - 1;
		while (true)
		{
			while (arr[++i] < key);//从左向右找比key大的值
			while (arr[--j] > key);//从右向左找比key小的值
			if (i > j)
			{
				break;
			}
			swap(&arr[i], &arr[j]);
		}
		swap(&arr[i], &arr[right - 1]);//将基准值与按顺序第一个大于基准值的元素交换，保证前面小于后面大于基准
		quicksort(arr, left, i - 1);//递归解决左边的
		quicksort(arr, i + 1, right);//递归解决右边的
	}
	else//当元素较少时，直接用简单插入排序
	{
		insertsort(arr + left, right - left + 1);
	}
	return 0;
}

int main()
{
	int arr[1000];
	int n;
	cout << "请输入数组中元素的个数：";
	cin >> n;
	cout << "请输入元素: " << endl;
	for (int i = 0; i < n; i++)
	{
		cin >> arr[i];
	}
	cout << "排序前：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	quicksort(arr, 0, n - 1);
	cout << "排序后：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	return 0;
}

运行结果如下：

二. 插入排序

1. 简单插入排序

• 介绍：
  插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
• 算法描述：
  一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

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

• 代码演示：

#include <iostream>
using namespace std;

int insertionSort(int arr[], int n)
{
	int temp, i, j;
	for (i = 1; i < n; i++)
	{
		temp = arr[i];
		for (j = i; j > 0 && arr[j - 1] > temp; j--)
		{
			arr[j] = arr[j - 1];
		}
		arr[j] = temp;
	}
	return 0;
}

int main()
{
	int arr[1000];
	int n;
	cout << "请输入数组中元素的个数：";
	cin >> n;
	cout << "请输入元素: " << endl;
	for (int i = 0; i < n; i++)
	{
		cin >> arr[i];
	}
	cout << "排序前：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	insertionSort(arr, n);
	cout << "排序后：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	return 0;
}

运行结果如下：

2. 希尔排序

• 介绍：
  1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
• 算法描述：
  先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

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

• 代码演示：

#include <iostream>
using namespace std;

int shellSort(int arr[], int n)
{
	for (int gap = n / 2; gap > 0; gap--)//确定增量
	{
		for (int i = gap; i < n; i += gap)//每次都间隔增量，将这些排序
		{
			int temp = arr[i];
			int j;
			for (j = i; j >= gap && arr[j - gap] > temp; j -= gap)
			{
				arr[j] = arr[j - gap];
			}
			arr[j] = temp;
		}
	}
	return 0;
}

int main()
{
	int arr[1000];
	int n;
	cout << "请输入数组中元素的个数：";
	cin >> n;
	cout << "请输入元素: " << endl;
	for (int i = 0; i < n; i++)
	{
		cin >> arr[i];
	}
	cout << "排序前：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	shellSort(arr, n);
	cout << "排序后：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	return 0;
}

运行结果如下：

三. 选择排序

1. 简单选择排序

• 介绍：
  选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
• 算法描述：
  n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

1. 初始状态：无序区为R[1…n]，有序区为空；
2. 第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个的新无序区；
3. n-1趟结束，数组有序化了。
   

• 代码演示：

#include <iostream>
using namespace std;

int selectionSort(int arr[], int n)
{
	for (int i = 0; i < n; i++)
	{
		int minIndex = i;
		for (int j = i + 1; j < n; j++)
		{
			if (arr[minIndex] > arr[j])
			{
				minIndex = j;
			}
		}
		int temp = arr[minIndex];
		arr[minIndex] = arr[i];
		arr[i] = temp;
	}
	return 0;
}

int main()
{
	int arr[1000];
	int n;
	cout << "请输入数组中元素的个数：";
	cin >> n;
	cout << "请输入元素: " << endl;
	for (int i = 0; i < n; i++)
	{
		cin >> arr[i];
	}
	cout << "排序前：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	selectionSort(arr, n);
	cout << "排序后：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	return 0;
}

运行结果如下：

2. 堆排序

• 介绍：
  堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
• 算法描述：
  将初始待排序关键字序列(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，则整个排序过程完成。
  
• 代码演示：

#include <iostream>
#include <algorithm>
using namespace std;

int percDown(int arr[], int p, int n)//建立最大堆
{
	int parent, child;//标记根结点和孩子结点
	int x;
	x = arr[p];
	for (parent = p; (parent * 2 + 1) < n; parent = child)
	{
		child = parent * 2 + 1;//获得孩子结点的下标
		if ((child != n - 1) && (arr[child] < arr[child + 1]))
		{
			child++;//指向左右子结点的较大者
		}
		if (x >= arr[child])//找到合适的位置，即根结点大于子结点
		{
			break;
		}
		else
		{
			arr[parent] = arr[child];//反之交换
		}
	}
	arr[parent] = x;
	return 0;
}

int swap(int *x, int *y)//交换
{
	int temp = *x;
	*x = *y;
	*y = temp;
	return 0;
}

int heapSort(int arr[], int n)//堆排序
{
	for (int i = n / 2 - 1; i >= 0; i--)
	{
		percDown(arr, i, n);//建立最大堆
	}
	for (int i = n - 1; i > 0; i--)
	{
		swap(&arr[0], &arr[i]);//将最大堆中的最大值放在arr[i]
		percDown(arr, 0, i);//然后用0-i创建最大堆获取最大值，即删除最大堆顶
	}
	return 0;
}

int main()
{
	int arr[1000];
	int n;
	cout << "请输入数组中元素的个数：";
	cin >> n;
	cout << "请输入元素: " << endl;
	for (int i = 0; i < n; i++)
	{
		cin >> arr[i];
	}
	cout << "排序前：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	heapSort(arr, n);
	cout << "排序后：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	return 0;
}

运行结果如下：

四. 归并排序

1. 二路归并排序

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

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

• 代码演示：

#include <iostream>
using namespace std;
//将arr[left]-arr[center-1]和arr[center]-arr[right]归并成一个序列
int merge(int arr[], int tmparr[], int left, int center, int right)
{
	int l_end = center - 1;//左边终点的位置
	int tmp = left;//有序序列的起始位置
	int len = right - left + 1;//总长度
	while (left <= l_end && center <= right)
	{
		if (arr[left] <= arr[center])//将小的元素先复制到tmparr中
		{
			tmparr[tmp++] = arr[left++];//将左边的元素复制到tmparr中
		}
		else
		{
			tmparr[tmp++] = arr[center++];//将右边的元素复制到tmparr中
		}
		
	}
	
	while (left <= l_end)//直接将左边剩下的所有元素都复制到tmparr中
	{
		tmparr[tmp++] = arr[left++];
	}
	while (center < right)//直接将右边剩下的所有元素都复制到tmparr中
	{
		tmparr[tmp++] = arr[center++];
	}
	//将有序的tmparr复制回arr中
	for (int i = 0; i < len; i++,right--)
	{
		arr[right] = tmparr[right];
	}
	return 0;
}


int msort(int arr[], int tmparr[], int left, int right)
{
	int center;
	if (left < right)
	{
		center = (left + right) / 2;
		msort(arr, tmparr, left, center);//递归解决左边
		msort(arr, tmparr, center + 1, right);//递归解决右边
		merge(arr, tmparr, left, center + 1, right);//合并两段有序序列并排序
	}
	return 0;
}

int mergeSort(int arr[], int n)
{
	int *tmparr;
	//创建一个数组，以便归并
	tmparr = (int *)malloc(n * sizeof(int));

	if (tmparr != NULL)
	{
		msort(arr, tmparr, 0, n - 1);
		//释放空间
		free(tmparr);
	}
	else
	{
		cout << "空间不足" << endl;
	}
	return 0;
}

int main()
{
	int arr[1000];
	int n;
	cout << "请输入数组中元素的个数：";
	cin >> n;
	cout << "请输入元素: " << endl;
	for (int i = 0; i < n; i++)
	{
		cin >> arr[i];
	}
	cout << "排序前：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	mergeSort(arr, n);
	cout << "排序后：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	return 0;
}

运行结果如下：