目录
-
-
- [4.1 排序算法](#4.1 排序算法)
-
- [4.1.1 **各种排序算法的时间空间复杂度、稳定性** ⭐⭐⭐⭐⭐](#4.1.1 各种排序算法的时间空间复杂度、稳定性 ⭐⭐⭐⭐⭐)
- [4.1.2 **各种排序算法什么时候有最好情况、最坏情况（尤其是快排）** ⭐⭐⭐⭐](#4.1.2 各种排序算法什么时候有最好情况、最坏情况（尤其是快排） ⭐⭐⭐⭐)
- [4.1.3 **冒泡排序** ⭐⭐⭐⭐](#4.1.3 冒泡排序 ⭐⭐⭐⭐)
- [4.1.4 **选择排序** ⭐⭐⭐⭐](#4.1.4 选择排序 ⭐⭐⭐⭐)
- [4.1.5 **插入排序** ⭐⭐⭐⭐](#4.1.5 插入排序 ⭐⭐⭐⭐)
- [4.1.6 **希尔排序** ⭐⭐⭐⭐](#4.1.6 希尔排序 ⭐⭐⭐⭐)
- [4.1.7 **归并排序** ⭐⭐⭐⭐](#4.1.7 归并排序 ⭐⭐⭐⭐)
- [4.1.8 **快速排序** ⭐⭐⭐⭐⭐](#4.1.8 快速排序 ⭐⭐⭐⭐⭐)
- [4.1.9 **快排的 partition 函数与归并的 Merge 函数** ⭐⭐⭐](#4.1.9 快排的 partition 函数与归并的 Merge 函数 ⭐⭐⭐)
-
4.1 排序算法
4.1.1 各种排序算法的时间空间复杂度、稳定性 ⭐⭐⭐⭐⭐
| 排序算法 | 平均时间复杂度 | 最好情况时间复杂度 | 最坏情况时间复杂度 | 空间复杂度 | 稳定性 |
|---|---|---|---|---|---|
| 冒泡排序 | O(n^2) | O(n) | O(n^2) | O(1) | 稳定 |
| 选择排序 | O(n^2) | O(n^2) | O(n^2) | O(1) | 不稳定 |
| 插入排序 | O(n^2) | O(n) | O(n^2) | O(1) | 稳定 |
| 希尔排序 | O(n log n) | O(n log^2 n) | O(n^2) | O(1) | 不稳定 |
| 归并排序 | O(n log n) | O(n log n) | O(n log n) | O(n) | 稳定 |
| 快速排序 | O(n log n) | O(n log n) | O(n^2) | O(log n) | 不稳定 |
- 稳定性：指的是如果两个元素相等，它们在排序前后的相对位置是否保持不变。
- 时间复杂度：算法执行所需的时间，通常表示为最坏、平均和最好情况。
- 空间复杂度：算法执行时所需的额外存储空间。
4.1.2 各种排序算法什么时候有最好情况、最坏情况（尤其是快排） ⭐⭐⭐⭐
-
冒泡排序：
- 最好情况：数组已经有序，时间复杂度为 O(n)。
- 最坏情况：数组逆序，时间复杂度为 O(n^2)。
-
选择排序：
- 无论数组是否有序，最好和最坏情况的时间复杂度都是 O(n^2)。
-
插入排序：
- 最好情况：数组已经有序，时间复杂度为 O(n)。
- 最坏情况：数组逆序，时间复杂度为 O(n^2)。
-
希尔排序：
- 最好情况：数组基本有序，时间复杂度接近 O(n log n)。
- 最坏情况：数组完全无序，时间复杂度为 O(n^2)。
-
归并排序：
- 最好和最坏情况的时间复杂度都是 O(n log n)，因为归并排序是分治算法，分割和合并的过程都不会依赖于数据的顺序。
-
快速排序：
- 最好情况：每次分割点恰好是数组的中位数，时间复杂度为 O(n log n)。
- 最坏情况：每次分割点总是选择最大或最小值，时间复杂度为 O(n^2)（通常在数组几乎有序或完全无序时发生）。改进方式是使用随机化或三数取中。
4.1.3 冒泡排序 ⭐⭐⭐⭐
cpp
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
bool swapped = false;
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
std::swap(arr[j], arr[j + 1]);
swapped = true;
}
}
if (!swapped)
break;
}
}4.1.4 选择排序 ⭐⭐⭐⭐
cpp
void selectionSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex])
minIndex = j;
}
std::swap(arr[i], arr[minIndex]);
}
}4.1.5 插入排序 ⭐⭐⭐⭐
cpp
void insertionSort(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}4.1.6 希尔排序 ⭐⭐⭐⭐
cpp
void shellSort(int arr[], int n) {
for (int gap = n / 2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {
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;
}
}
}4.1.7 归并排序 ⭐⭐⭐⭐
cpp
void merge(int arr[], int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
int L[n1], R[n2];
for (int i = 0; i < n1; i++)
L[i] = arr[left + i];
for (int i = 0; i < n2; i++)
R[i] = arr[mid + 1 + i];
int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j])
arr[k++] = L[i++];
else
arr[k++] = R[j++];
}
while (i < n1)
arr[k++] = L[i++];
while (j < n2)
arr[k++] = R[j++];
}
void mergeSort(int arr[], int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}4.1.8 快速排序 ⭐⭐⭐⭐⭐
cpp
int partition(int arr[], int low, int high) {
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j <= high - 1; j++) {
if (arr[j] < pivot) {
i++;
std::swap(arr[i], arr[j]);
}
}
std::swap(arr[i + 1], arr[high]);
return (i + 1);
}
void quickSort(int arr[], int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}4.1.9 快排的 partition 函数与归并的 Merge 函数 ⭐⭐⭐
-
Partition 函数（用于快速排序）：
- 用来确定一个枢轴（pivot），将数组划分为两部分，使得枢轴左边的元素小于枢轴，右边的元素大于枢轴。
- 快排基于分治思想，利用递归将划分后的部分继续排序。
-
Merge 函数（用于归并排序）：
- 用来合并两个已经排序的数组，形成一个有序数组。
- 归并排序的分治过程首先对数组分割，然后通过Merge函数逐步将有序的子数组合并成最终的有序数组。