在算法的江湖里，排序算法就像是一群身怀绝技的高手，它们各有所长，在不同的场景下大显身手。作为 C++ 算法小白的我，今天就带大家一起去认识这八位排序高手，看看它们是如何在数据的世界里排兵布阵的。
1. 冒泡排序（Bubble Sort）：慢悠悠的老者
冒泡排序就像是一位慢悠悠的老者，一步一步地把数据中较大的元素 “浮” 到数组的末尾。它的基本思想是多次遍历数组，比较相邻的元素，如果顺序错误就把它们交换过来。
代码示例
cpp
#include <iostream>
#include <vector>
void bubbleSort(std::vector<int>& arr) {
int n = arr.size();
for (int i = 0; i < n - 1; ++i) {
for (int j = 0; j < n - i - 1; ++j) {
if (arr[j] > arr[j + 1]) {
// 交换 arr[j] 和 arr[j+1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
详细解释
- 外层循环控制排序的轮数，每一轮都会把一个最大的元素放到数组的末尾。
- 内层循环比较相邻的元素，如果前面的元素比后面的大，就交换它们的位置。
例题讲解
假设有数组 [5, 3, 8, 4, 2]，第一轮排序后，最大的元素 8 会被放到数组的末尾，数组变为 [3, 5, 4, 2, 8]。经过多轮排序，最终数组会变成 [2, 3, 4, 5, 8]。
2. 选择排序（Selection Sort）：挑剔的挑选者
选择排序就像一个挑剔的挑选者，每次都从剩余的元素中选出最小的元素，然后放到已排序部分的末尾。
代码示例
cpp
#include <iostream>
#include <vector>
void selectionSort(std::vector<int>& arr) {
int n = arr.size();
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;
}
}
// 交换 arr[i] 和 arr[minIndex]
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
详细解释
- 外层循环控制已排序部分的末尾位置。
- 内层循环从剩余的元素中找到最小的元素，并记录其索引。
- 最后交换最小元素和已排序部分的下一个位置的元素。
例题讲解
对于数组 [5, 3, 8, 4, 2]，第一轮会找到最小的元素 2，并和第一个元素 5 交换位置，数组变为 [2, 3, 8, 4, 5]。经过多轮排序，最终数组会排好序。
3. 插入排序（Insertion Sort）：有序的插入者
插入排序就像一个有序的插入者，它将未排序的数据插入到已排序序列的合适位置。
代码示例
cpp
#include <iostream>
#include <vector>
void insertionSort(std::vector<int>& arr) {
int n = arr.size();
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;
}
}
详细解释
- 外层循环从第二个元素开始，将其视为未排序的元素。
- 内层循环将未排序的元素插入到已排序序列的合适位置。
例题讲解
对于数组 [5, 3, 8, 4, 2]，当处理元素 3 时，会将其插入到 5 的前面，数组变为 [3, 5, 8, 4, 2]。随着循环的进行，数组会逐渐排好序。
4. 希尔排序（Shell Sort）：分组的革新者
希尔排序是插入排序的改进版，它通过将数组分成多个子数组进行插入排序，从而减少元素的移动次数。
代码示例
cpp
#include <iostream>
#include <vector>
void shellSort(std::vector<int>& arr) {
int n = arr.size();
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;
}
}
}
详细解释
- 首先确定一个间隔
gap，将数组分成多个子数组，对每个子数组进行插入排序。 - 然后逐渐减小间隔
gap，直到gap为1，此时进行最后一次插入排序，数组就排好序了。
例题讲解
对于数组 [5, 3, 8, 4, 2]，假设初始间隔 gap = 2，会将数组分成 [5, 8, 2] 和 [3, 4] 两个子数组分别进行插入排序。随着 gap 的减小，最终数组会排好序。
5. 归并排序（Merge Sort）：分治的大师
归并排序是一位分治的大师，它将数组分成两个子数组，分别对这两个子数组进行排序，然后将排好序的子数组合并成一个有序的数组。
代码示例
cpp
#include <iostream>
#include <vector>
void merge(std::vector<int>& arr, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
std::vector<int> L(n1), R(n2);
for (int i = 0; i < n1; ++i) {
L[i] = arr[left + i];
}
for (int j = 0; j < n2; ++j) {
R[j] = arr[mid + 1 + j];
}
int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
++i;
} else {
arr[k] = R[j];
++j;
}
++k;
}
while (i < n1) {
arr[k] = L[i];
++i;
++k;
}
while (j < n2) {
arr[k] = R[j];
++j;
++k;
}
}
void mergeSort(std::vector<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);
}
}
详细解释
mergeSort函数将数组递归地分成两个子数组，直到每个子数组只有一个元素。merge函数将两个排好序的子数组合并成一个有序的数组。
例题讲解
对于数组 [5, 3, 8, 4, 2]，首先会将其分成 [5, 3] 和 [8, 4, 2]，然后继续细分，直到每个子数组只有一个元素。最后通过 merge 函数将这些子数组合并成一个有序的数组。
6. 快速排序（Quick Sort）：神速的剑客
快速排序就像一位神速的剑客，它选择一个基准元素，将数组分成两部分，使得左边的元素都小于等于基准元素，右边的元素都大于基准元素，然后递归地对左右两部分进行排序。
代码示例
cpp
#include <iostream>
#include <vector>
int partition(std::vector<int>& arr, int low, int high) {
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; ++j) {
if (arr[j] <= pivot) {
++i;
// 交换 arr[i] 和 arr[j]
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// 交换 arr[i+1] 和 arr[high]
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return i + 1;
}
void quickSort(std::vector<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);
}
}
详细解释
partition函数选择一个基准元素，将数组分成两部分，并返回基准元素的最终位置。quickSort函数递归地对左右两部分进行排序。
例题讲解
对于数组 [5, 3, 8, 4, 2]，假设选择最后一个元素 2 作为基准元素，经过 partition 函数处理后，数组会变成 [2, 3, 4, 5, 8]，然后递归地对左右两部分进行排序。
7. 堆排序（Heap Sort）：堆结构的舞者
堆排序利用堆这种数据结构进行排序，它首先将数组构建成一个最大堆，然后不断地将堆顶元素（最大值）与堆的最后一个元素交换，并调整堆，直到堆为空。
代码示例
cpp
#include <iostream>
#include <vector>
void heapify(std::vector<int>& arr, int n, int i) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
if (largest != i) {
// 交换 arr[i] 和 arr[largest]
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
heapify(arr, n, largest);
}
}
void heapSort(std::vector<int>& arr) {
int n = arr.size();
for (int i = n / 2 - 1; i >= 0; --i) {
heapify(arr, n, i);
}
for (int i = n - 1; i > 0; --i) {
// 交换 arr[0] 和 arr[i]
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
heapify(arr, i, 0);
}
}
详细解释
heapify函数用于调整堆，使得以i为根的子树满足最大堆的性质。heapSort函数首先将数组构建成一个最大堆，然后不断地将堆顶元素与堆的最后一个元素交换，并调整堆。
例题讲解
对于数组 [5, 3, 8, 4, 2]，首先将其构建成一个最大堆，然后将堆顶元素 8 与最后一个元素 2 交换，再调整堆。重复这个过程，直到数组排好序。
8. 计数排序（Counting Sort）：统计的智者
计数排序是一种非比较排序算法，它通过统计每个元素出现的次数，然后根据统计结果将元素放回原数组，从而实现排序。
代码示例
cpp
#include <iostream>
#include <vector>
void countingSort(std::vector<int>& arr) {
int maxVal = 0;
for (int num : arr) {
if (num > maxVal) {
maxVal = num;
}
}
std::vector<int> count(maxVal + 1, 0);
for (int num : arr) {
++count[num];
}
int index = 0;
for (int i = 0; i <= maxVal; ++i) {
while (count[i] > 0) {
arr[index] = i;
++index;
--count[i];
}
}
}
详细解释
- 首先找出数组中的最大值
maxVal。 - 然后创建一个计数数组
count，统计每个元素出现的次数。 - 最后根据计数数组将元素放回原数组。
例题讲解
对于数组 [5, 3, 8, 4, 2]，计数数组会统计每个元素出现的次数，然后根据统计结果将元素按顺序放回原数组，实现排序。
总结
这八位排序高手各有优缺点，在不同的场景下有不同的表现。冒泡排序、选择排序和插入排序比较简单，但时间复杂度较高，适用于小规模数据的排序。希尔排序、归并排序、快速排序和堆排序的时间复杂度较低，适用于大规模数据的排序。计数排序是一种非比较排序算法，适用于数据范围较小的情况。作为算法小白，我们要根据具体的问题选择合适的排序算法，才能在算法的江湖里游刃有余。
希望大家通过这篇文章对这八种排序算法有了更深入的了解，让我们一起在算法的世界里继续探索吧！
扫一扫
2505
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
