C++介绍排序算法-优快云博客

本文链接：https://blog.youkuaiyun.com/zfjkdfhduhsdk/article/details/146608479

一、基础排序算法（�(�2)O(n2)）

1. 冒泡排序

原理：通过相邻元素比较交换，将最大元素逐渐“冒泡”到末尾
C++实现：

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

特点：稳定排序，原地操作，适合小数据量

2. 选择排序

原理：每次选择未排序部分的最小元素，放到已排序序列末尾
C++实现：

void selectionSort(vector<int>& arr) {
for (int i = 0; i < arr.size()-1; ++i) {
int minIdx = i;
for (int j = i+1; j < arr.size(); ++j) {
if (arr[j] < arr[minIdx]) minIdx = j;
}
swap(arr[i], arr[minIdx]);
}
}

特点：不稳定排序，交换次数少（�(�)O(n)次）

3. 插入排序

原理：将每个元素插入到已排序序列中的正确位置
C++实现：

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

特点：稳定排序，适合近乎有序的数据

二、高效排序算法（�(�log⁡�)O(nlogn)）

1. 快速排序

原理：分治法，选取基准元素将数组划分为两个子数组
C++实现：

int partition(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) {
swap(arr[++i], arr[j]);
}
}
swap(arr[i+1], arr[high]);
return i+1;
}

void quickSort(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);
}
}

特点：平均最快，但最坏情况�(�2)O(n2)，不稳定

2. 归并排序

原理：分治法，将数组分为两半分别排序后合并
C++实现：

void merge(vector<int>& arr, int l, int m, int r) {
vector<int> temp(r-l+1);
int i = l, j = m+1, k = 0;
while (i <= m && j <= r) {
temp[k++] = (arr[i] <= arr[j]) ? arr[i++] : arr[j++];
}
while (i <= m) temp[k++] = arr[i++];
while (j <= r) temp[k++] = arr[j++];
for (int p = 0; p < k; ++p) arr[l+p] = temp[p];
}

void mergeSort(vector<int>& arr, int l, int r) {
if (l >= r) return;
int m = l + (r-l)/2;
mergeSort(arr, l, m);
mergeSort(arr, m+1, r);
merge(arr, l, m, r);
}

特点：稳定排序，需要�(�)O(n)额外空间

3. 堆排序

原理：利用最大堆数据结构进行排序
C++实现：

void heapify(vector<int>& arr, int n, int i) {
int largest = i, l = 2*i+1, r = 2*i+2;
if (l < n && arr[l] > arr[largest]) largest = l;
if (r < n && arr[r] > arr[largest]) largest = r;
if (largest != i) {
swap(arr[i], arr[largest]);
heapify(arr, n, largest);
}
}

void heapSort(vector<int>& arr) {
// 建堆
for (int i = arr.size()/2-1; i >= 0; --i)
heapify(arr, arr.size(), i);
// 排序
for (int i = arr.size()-1; i > 0; --i) {
swap(arr[0], arr[i]);
heapify(arr, i, 0);
}
}

特点：原地排序，不稳定，适合大数据量

三、特殊场景排序

1. 计数排序（�(�+�)O(N+K)）

适用整数排序，k为数据范围

2. 基数排序（�(�(�+�))O(D(N+K))）

按位数逐位排序

3. 桶排序（�(�)O(N)）

数据均匀分布时高效

四、对比总结

算法	平均时间复杂度	空间复杂度	稳定性	适用场景
冒泡排序	�(�2)O(n2)	�(1)O(1)	稳定	教学示例
快速排序	�(�log⁡�)O(nlogn)	�(log⁡�)O(logn)	不稳定	通用排序
归并排序	�(�log⁡�)O(nlogn)	�(�)O(n)	稳定	链表排序、外部排序
堆排序	�(�log⁡�)O(nlogn)	�(1)O(1)	不稳定	内存受限场景