### 常见排序算法概述
常见的排序算法可以根据其原理划分为两大类：比较类排序和非比较类排序。以下是这些算法的具体介绍以及它们的实现方式。
#### 比较类排序算法
这类排序算法通过元素之间的比较来决定顺序，主要包括以下几种：
1. **冒泡排序 (Bubble Sort)**
冒泡排序是一种简单的排序方法，它重复遍历待排序列表，每次比较相邻的两个元素并交换位置，直到整个列表有序为止。它的平均时间和最坏情况下的时间复杂度均为 \(O(n^2)\)[^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;
}
}
```
2. **选择排序 (Selection Sort)**
选择排序的核心思想是在未排序部分找到最小（或最大）值，并将其放到已排序部分的末尾。此算法的时间复杂度始终为 \(O(n^2)\)，无论输入数据如何分布[^3]。
```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]);
}
}
```
3. **插入排序 (Insertion Sort)**
插入排序的工作机制类似于人们整理扑克牌的过程，即将新元素逐步插入到已经排好序的部分中。对于几乎有序的数据集，插入排序表现优异，最佳情况下时间复杂度可达到 \(O(n)\)[^4]。
```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. **归并排序 (Merge Sort)**
归并排序基于分治策略，将数组分成两半分别递归排序后再合并起来。这种算法具有稳定的性能，在任何情况下都能保持 \(O(n \log n)\) 的时间复杂度[^1]。
```cpp
void merge(int arr[], int l, int m, int r) {
// 合并逻辑...
}
void mergeSort(int arr[], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
```
5. **快速排序 (Quick Sort)**
快速排序也是一种典型的分治算法，通过选取一个“基准”元素将数组分割成左右两部分，然后再对这两部分递归调用快速排序函数。尽管最差情况下时间复杂度可能退化至 \(O(n^2)\)，但在实际应用中通常能接近于 \(O(n \log n)\)[^2]。
```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);
}
}
```
#### 非比较类排序算法
此类排序不依赖于键值间的直接对比关系，而是利用特定属性完成排列过程，因此理论上能够突破传统比较模型中的下限约束 (\(O(n \log n)\))。
1. **计数排序 (Counting Sort)**
计数排序适用于一定范围内的整数排序场景，通过对每个数值统计出现次数的方式构建最终结果集合。如果输入数据的最大值与最小值差距较大，则空间开销会显著增加。
```cpp
void countingSort(int arr[], int size) {
int maxVal = *std::max_element(arr, arr + size);
int* countArr = new int[maxVal + 1]{};
for (int i = 0; i < size; ++i) {
countArr[arr[i]]++;
}
int index = 0;
for (int i = 0; i <= maxVal; ++i) {
while (countArr[i]-- > 0) {
arr[index++] = i;
}
}
delete[] countArr;
}
```
2. **桶排序 (Bucket Sort)** 和 **基数排序 (Radix Sort)** 等其他高效算法也属于这一类别，但由于篇幅所限不再展开讨论。
---
### 总结
上述列举了几种经典的排序技术及其对应的代码片段展示，每一种都有各自适用场合及优缺点考量因素。读者可根据具体需求选用合适的方案加以实践验证效果差异。
本文深入探讨了计算机科学中的几种主要排序算法，包括冒泡排序、选择排序、插入排序、快速排序和归并排序。通过详细步骤解析，帮助读者理解每种排序算法的工作原理及其效率。此外，还讨论了它们在实际应用中的优缺点，为程序员在不同场景下选择合适排序算法提供指导。
扫一扫
1868
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
