[Leetcode] 常见排序算法的标准模板

前言

排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。

分类

假设在待排序的文件中，存在两个或两个以上的记录具有相同的关键字，在用某种排序法排序后，若这些相同关键字的元素的相对次序仍然不变，则这种排序方法是稳定的，反之则称不稳定的。

冒泡排序

基本思想

两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

void bubbleSort(vector<int> &a) {
   
   
	int n = a.size();
	bool flag = true; // 标记是否发生了交换
	for (int i = 1; i < n && flag; ++i) {
   
   
		flag = false;
		for (int j = n - 1; j >= i; --j) {
   
   
			if (a[j] > a[j + 1]) {
   
   
				swap(a[j], a[j + 1]);
				flag = true;
			}
		}
	}
}

复杂度分析

最好的情况，也就是要排序的表本身就是有序的，那么需要 $n-1$ 次比较，没有数据交换，时间复杂度为 $O(n)$。
最差的情况，即待排序表是逆序的情况，此时需要比较 ${\sum }_{i=2}^n(i-1)=\frac{n(n-1)}{2}$ 次，并作等数量级的记录移动。因此，总时间复杂度为 $O(n^2)$。

简单选择排序

基本思想

通过 $n-i$ 次关键字间的比较，从 $n-i+1$ 个记录中选出关键字最小（或最大）的记录，并和第 $i(1\le i\le n)$ 个记录交换。

void selectionSort(vector<int> &a) {
   
   
	int n = a.size();
	for (int i = 0; i < n; ++i) {
   
   
		int min = i; // 无序区中最小元素位置
		for (int j = i + 1; j < n; ++j) {
   
   
			if (a[j] < a[min]) {
   
   
				min = j;
			}
			if (i != min) {
   
   
				swap(a[i], a[min]);
			}
		}
	}
}

复杂度分析

无论最好最差情况，其比较次数都是一样多，第 $i$ 躺排序需要进行 $n-i$ 次关键字的比较，需要 ${\sum }_{i=1}^n(n-i)=\frac{n(n-1)}{2}$ 次。因此，总的时间复杂度为 $O(n^2)$。尽管与冒泡排序同为 $O(n^2)$，但性能上要略优于冒泡排序。

直接插入排序

基本思想

将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增 1 的有序表。

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

复杂度分析

当最好的情况，也就是要排序的表本身就是有序的，那么总共比较了 $(n-1)({\sum }_{i=2}^{n}1)$ 次，没有移动的记录，时间复杂度为 $O(n)$。
当最坏的情况，也就是要排序的表是逆序的，需要比较 ${\sum }_{i=2}^{n}i=\frac{(}{2}$