数据结构之排序算法

一、排序基本概念

• 稳定性：

假设两个值（$a_1,a_2$）相同，如果经过某一排序算法排序后两值的前后顺序不会发生改变，则称之为稳定排序，否则，为不稳定排序。

• 平均排序复杂度：

• 简单排序：时间复杂度为$O(n^2)$
• 先进排序：时间复杂度为$O(nlogn)$
• 基数排序：时间复杂度为$O(d\ast n)$

二、排序算法思路与代码实现

2.1 简单排序

简单排序包括三个:选择、插入、冒泡，共同点是他们都是稳定的，平均和最坏都是$O(n^2)$，辅助空间都是$O(1)$

2.1.1 选择排序

一趟排序思路：每次在无序序列中找到一个最小值，让最小值与无序序列和有序序列的交界处的那个无序值交换。
代码：

void SelectSort(vector<int> L) {
	for (int i = 1; i < L.size(); i++) { // 0位置的值自己有序
		int k = i; // k为最小值的索引
		// 找到无序序列中的最小值
		for (int j = i + 1; j < L.size(); j++) {
			if (L[j] < L[k]) k = j;
		}
		// 交换值
		if (i != k) { // i 就是交界后一个的位置
			//swap
			int w = L[i];
			L[i] = L[k];
			L[k] = w;
		}
	}
}

时间复杂度：最好最坏都是$O(n^2)$，稳定排序。

2.1.2 插入排序

排序思路：后面的值，寻找前面的合适的位置插进去。前面的需要一个个的挪位置。
初始状态，0处为“哨兵”，1处为“有序”，之后数值为“无序”。对某个“无序”值$L_i$找位置排序，如果$L_i<L_{i-1}$说明需要排序。先把这个值复制到“哨兵”的位置保证不会丢失，然后for循环的一个个向后移动。最后把“哨兵”插入到适当的位置。
代码：

void InsertSort(vector<int>& L) {
	int n = L.size();
	for (int i = 2; i < n; i++) {
		if (L[i] < L[i - 1]) {
			L[0] = L[i];
			int j = i - 1;
			while(L[0] < L[j]) {
				L[j + 1] = L[j];
				j--;
			}
			L[j + 1] = L[0];
		}
	}
}

特性：稳定、两个for循环：最坏情况原序列逆序，$O(n^2)$；最好情况原序列有序，n-1次。空间复杂度为$O(1)$，因为需要挪动太多位置，所以不适合对大量数据进行排序。

2.1.3冒泡排序

一趟排序思路：两两比较大小，大数在上则交换位置。
代码：

void BubbleSort(vector<int>& a) {
	int n = a.size();
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n - i - 1; j++) {
			if (a[j + 1] < a[j]) {
				//swap(a[j + 1], a[j]);		
				int temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
	}
}

特性：稳定、两个for循环：最坏情况原序列逆序，$O(n^2)$；最好情况原序列有序，n-1次。空间复杂度为$O(1)$

2.2 先进排序

共性：最好和平均都是$O(nlogn)$

2.2.1 快速排序（不稳定）

一堂排序思路：找个值，让左边的都小于它，右边的都大于它。
代码：

// 对记录子序列进行一趟排序，并返回枢轴的位置。
int Partition(vector<int>& L, int low, int high){
	L[0] = L[low]; // L[0]作为哨兵
	pivotkey = L[low]; // pivot：枢轴，刚开始时选定最左边值作为枢轴
	while (low < high) {

		while (low < high && L[high] >= pivotkey) {
			--high;
		}
		if (low < high) L[low++] = L[high];
		
		while (low < high && L[low] <= pivotkey) {
			++low;
		}
		if (low < high) L[high--] = L[low];
	}
	L[low] = L[0];
	return low;
}
// 递归进行排序
void QSort(vector<int> &L, int s, int t) {
	if (s < t) {
		pivotloc = Partition(L, s, t);
		QSort(L, s, pivotloc - 1);
		QSort(L, pivotloc + 1, t);
	}
}

void QuickSort(vector<int>& L) {
	QSort(L, 1, L.size()); // 对所以1~len的值进行排序
}

快排最坏时会退化为$O(n^2)$，并且不稳定。

2.2.2 归并排序（稳定）

排序思想：

一趟排序思路：将两个位置相邻的有序记录子序列归并为一个有序记录序列。
　再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。
　

代码：

// 将R[i...m] R[m+1...n]合并为L;
void Merge(vector<int>& T, vector<int> &L,  int i, int m, int n) {
	// 迭代器：i，j，k
	// k,指示应该存放的位置
	// i, j ,指示应该进行对比的两个值得位置
	for (int j = m + 1, k = i; i <= m && j <= n; ++k) {
		if (T[i] <= T[j]) L[k] = R[i++];
		else L[k] = R[j++];
	}
	while (i <= m) L[k++] = T[i++]; // 将剩余的T[i...m]复制到L
	while (j <= n) L[k++] = T[j++]; // 将剩余的T[j...n]复制到L
}
// 对L[s..t]进行归并排序，排序后的记录存入LR中
void Msort(vector<int> &L, vector<int> &LR, int s, int t) {

	vector<int> LTemp(t - s + 1); // 用于存放排好序的数组而开辟的临时变量
	
	if (s == t) {  // 如果要排序的序列中只有一个值
		L[s] = LR[s];
	}else {
		m = (s + t) / 2;
		Msort(L, LTemp, s, m); // 即，左边变为有序
		Msort(L, LTemp, m + 1, t); // 右边变为有序
		Merge(LTemp, L, s, m, t);  // 将一个两边都有序的序列，合并为一个整体有序的序列
	}
}

void MergeSort(vector<int>& L) {
	MSort(L, L, 1, L.size());
}

2.2.3 堆排序（不稳定）

思路：对序列的前n~1个记录不断地建立“大顶堆”，每次挑选最大值放到记录的最后，完成排序。

2.3 基数排序

三、c++调用STL排序算法

从小到大排序
从大到小排序
结构体/类排序

四、参考文章：

参考1
参考2