本文详细介绍了C++实现的十大排序算法，包括冒泡排序、快速排序、选择排序、插入排序、归并排序、希尔排序、计数排序、基数排序、桶排序和堆排序。通过示例代码展示了每种排序算法的工作原理和实现过程，帮助读者深入理解各种排序算法的优缺点和适用场景。
C++十大排序算法示例
目录：
冒泡排序
该函数有两个嵌套循环，外部循环遍历数组元素，内部循环比较相邻的元素，如果顺序错误，则交换它们。
#include <iostream>
#include <vector>
void bubble_sort(std::vector<int>& vec) {
for (int i = 0; i < vec.size() - 1; i++) {
for (int j = 0; j < vec.size() - i - 1; j++) {
if (vec[j] > vec[j + 1]) {
std::swap(vec[j], vec[j + 1]);
}
}
}
}
int main() {
std::vector<int> vec = { 5, 2, 4, 6, 1, 3 };
bubble_sort(vec);
for (int i : vec) {
std::cout << i << " ";
}
std::cout << std::endl;
return 0;
}
快速排序
定义一个函数quick_sort，该函数以一个整数数组和要排序的范围内第一个和最后一个元素的下标作为参数。该函数的工作原理是选择一个主元，并将范围的元素划分为两组:小于或等于主元的元素，以及大于主元的元素。然后使用quick_sort函数递归地对两组元素进行排序。
定义一个辅助函数partition，该函数以一个数组、要分区的范围内第一个和最后一个元素的索引以及一个枢轴元素作为参数。它重新排列范围内的元素，使所有小于或等于枢轴的元素都放在枢轴之前，所有大于枢轴的元素都放在它之后。
#include <iostream>
#include <vector>
int partition(std::vector<int>& vec, int low, int high) {
int pivot = vec[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (vec[j] <= pivot) {
i++;
std::swap(vec[i], vec[j]);
}
}
std::swap(vec[i + 1], vec[high]);
return i + 1;
}
void quick_sort(std::vector<int>& vec, int low, int high) {
if (low < high) {
int pivot_index = partition(vec, low, high);
quick_sort(vec, low, pivot_index - 1);
quick_sort(vec, pivot_index + 1, high);
}
}
int main() {
std::vector<int> vec = { 5, 2, 4, 6, 1, 3 };
quick_sort(vec, 0, vec.size() - 1);
for (int i : vec) {
std::cout << i << " ";
}
std::cout << std::endl;
return 0;
}
选择排序
函数有两个嵌套循环,外部循环遍历数组的元素，内部循环查找数组未排序部分的最小元素。然后将最小值元素与当前元素交换。
#include <iostream>
#include <vector>
void selection_sort(std::vector<int>& vec) {
for (int i = 0; i < vec.size() - 1; i++) {
int min_index = i;
for (int j = i + 1; j < vec.size(); j++) {
if (vec[j] < vec[min_index]) {
min_index = j;
}
}
std::swap(vec[i], vec[min_index]);
}
}
int main() {
std::vector<int> vec = { 5, 2, 4, 6, 1, 3 };
selection_sort(vec);
for (int i : vec) {
std::cout << i << " ";
}
std::cout << std::endl;
return 0;
}
插入排序
该函数有一个遍历vector元素的循环和一个嵌套循环，该循环将vector中已排序部分的元素向右移动，为当前元素腾出空间。然后将当前元素插入到向量的已排序部分中的正确位置。
#include <iostream>
#include <vector>
void insertion_sort(std::vector<int>& vec) {
for (int i = 1; i < vec.size(); i++) {
int key = vec[i];
int j = i - 1;
while (j >= 0 && vec[j] > key) {
vec[j + 1] = vec[j];
j--;
}
vec[j + 1] = key;
}
}
int main() {
std::vector<int> vec = { 5, 2, 4, 6, 1, 3 };
insertion_sort(vec);
for (int i : vec) {
std::cout << i << " ";
}
std::cout << std::endl;
return 0;
}
归并排序
以一个整数数组和要排序的范围内第一个和最后一个元素的下标作为参数。工作原理是将范围分为两部分，使用merge_sort函数递归地对每一半进行排序，然后使用merge函数合并两个排序。
#include <iostream>
#include <vector>
void merge(std::vector<int>& vec, int low, int mid, int high) {
std::vector<int> left(vec.begin() + low, vec.begin() + mid + 1);
std::vector<int> right(vec.begin() + mid + 1, vec.begin() + high + 1);
int i = 0, j = 0, k = low;
while (i < left.size() && j < right.size()) {
if (left[i] <= right[j]) {
vec[k] = left[i];
i++;
} else {
vec[k] = right[j];
j++;
}
k++;
}
while (i < left.size()) {
vec[k] = left[i];
i++;
k++;
}
while (j < right.size()) {
vec[k] = right[j];
j++;
k++;
}
}
void merge_sort(std::vector<int>& vec, int low, int high) {
if (low < high) {
int mid = (low + high) / 2;
merge_sort(vec, low, mid);
merge_sort(vec, mid + 1, high);
merge(vec, low, mid, high);
}
}
int main() {
std::vector<int> vec = { 5, 2, 4, 6, 1, 3 };
merge_sort(vec, 0, vec.size() - 1);
for (int i : vec) {
std::cout << i << " ";
}
std::cout << std::endl;
return 0;
}
希尔排序
希尔排序是一种插入排序的变体，它的核心思想是将数组分成若干个小的区间，然后在每个区间内进行插入排序。
具体来说，希尔排序首先会计算出一个间隔序列，然后对数组进行多轮排序，每轮排序时使用不同的间隔将数组分成若干个小区间。每个区间内部使用插入排序进行排序。
#include <iostream>
#include <vector>
using namespace std;
// 希尔排序
void shell_sort(vector<int>& nums) {
// 计算间隔序列
int gap = nums.size() / 2;
while (gap > 0) {
// 对数组进行多轮排序
for (int i = gap; i < nums.size(); i++) {
// 对区间内部使用插入排序
for (int j = i; j >= gap && nums[j - gap] > nums[j]; j -= gap) {
swap(nums[j - gap], nums[j]);
}
}
// 计算下一轮的间隔
gap /= 2;
}
}
int main() {
// 示例数组
vector<int> nums{5, 3, 1, 4, 2};
// 调用希尔排序
shell_sort(nums);
// 输出排序后的数组
for (int num : nums) {
cout << num << " ";
}
cout << endl;
return 0;
}
计数排序
计数排序是一种线性排序算法，它可以在 O(n) 的时间内将数组排序。计数排序的思路是，统计数组中每个数字出现的次数，然后根据次数将数字放到对应的位置。
下面是使用 C++ 实现计数排序的代码示例：
#include <iostream>
#include <vector>
// 计数排序函数
void countSort(std::vector<int>& arr) {
// 找出数组中的最大值
int max = arr[0];
for (int i = 1; i < arr.size(); i++) {
if (arr[i] > max) {
max = arr[i];
}
}
// 统计每个数字出现的次数
std::vector<int> count(max + 1);
for (int i = 0; i < arr.size(); i++) {
count[arr[i]]++;
}
// 根据次数将数字放到对应的位置
int k = 0;
for (int i = 0; i <= max; i++) {
for (int j = 0; j < count[i]; j++) {
arr[k++] = i;
}
}
}
int main() {
std::vector<int> arr {3, 5, 1, 7, 2, 4, 9, 6, 8};
countSort(arr);
for (int num : arr) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
基数排序
基数排序是一种分配式排序算法，它可以在 O(dn) 的时间内将数组排序，其中 d 是数字的最大位数。基数排序的思路是，将数字按照位数分别放到对应的桶中，然后按照桶的顺序将数字依次取出。
下面是使用 C++ 实现基数排序的代码示例：
#include <iostream>
#include <vector>
#include <algorithm>
const int DIGIT_COUNT = 10;
void radix_sort(std::vector<int>& vec) {
int max_value = *std::max_element(vec.begin(), vec.end());
int digit_count = 0;
while (max_value > 0) {
digit_count++;
max_value /= DIGIT_COUNT;
}
std::vector<std::vector<int>> buckets(DIGIT_COUNT);
for (int i = 0; i < digit_count; i++) {
for (int j = 0; j < vec.size(); j++) {
buckets[vec[j] / static_cast<int>(std::pow(DIGIT_COUNT, i)) % DIGIT_COUNT].push_back(vec[j]);
}
int k = 0;
for (int j = 0; j < DIGIT_COUNT; j++) {
for (int l = 0; l < buckets[j].size(); l++) {
vec[k] = buckets[j][l];
k++;
}
}
for (int j = 0; j < DIGIT_COUNT; j++) {
buckets[j].clear();
}
}
}
int main() {
std::vector<int> vec = { 5, 2, 4, 6, 1, 3 };
radix_sort(vec);
for (int i : vec) {
std::cout << i << " ";
}
std::cout << std::endl;
return 0;
}
桶排序
桶排序是一种非比较型排序算法，它可以在 O(n) 的时间内将数组排序。桶排序的思路是，建立若干个桶，每个桶用于存储一定范围内的数字。然后，将数组中的数字放到对应的桶中，最后将每个桶中的数字按照顺序依次取出。
下面是使用 C++ 实现桶排序的代码示例：
#include <iostream>
#include <vector>
// 桶排序函数
void bucketSort(std::vector<int>& arr) {
// 找出数组中的最大值和最小值
int min = arr[0], max = arr[0];
for (int i = 1; i < arr.size(); i++) {
if (arr[i] < min) {
min = arr[i];
}
if (arr[i] > max) {
max = arr[i];
}
}
// 建立桶
std::vector<std::vector<int>> bucket(max - min + 1);
// 将数字放到对应的桶中
for (int i = 0; i < arr.size(); i++) {
bucket[arr[i] - min].push_back(arr[i]);
}
// 将桶中的数字按照顺序依次取出
int k = 0;
for (int i = 0; i < bucket.size(); i++) {
for (int j = 0; j < bucket[i].size(); j++) {
arr[k++] = bucket[i][j];
}
}
}
int main() {
std::vector<int> arr {3, 5, 1, 7, 2, 4, 9, 6, 8};
bucketSort(arr);
for (int num : arr) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
堆排序
堆排序是一种排序算法，它使用堆这种数据结构来实现。堆是一种完全二叉树，其中每个节点都大于等于（或小于等于）它的子节点。在堆排序中，我们使用最大堆（或最小堆）来对数组进行排序。
堆排序的基本步骤如下：
- 建堆。首先将数组建成堆，这一步需要调用一个名为 heapify 的函数，该函数会将数组转化为堆。
- 取出堆顶。将堆顶（也就是堆中最大（或最小）的元素）取出并放到堆的末尾，然后对剩余的元素重新建堆。
- 重复步骤 2，直到堆中只剩下一个元素为止。
下面是一个 C++ 实现的堆排序算法：
#include <iostream>
#include <vector>
// 堆排序函数
void heapSort(std::vector<int>& arr) {
// 调整堆的函数
auto adjustHeap = [&arr](int i, int n) {
int j = i * 2 + 1;
while (j < n) {
if (j + 1 < n && arr[j] < arr[j + 1]) {
j++;
}
if (arr[i] < arr[j]) {
std::swap(arr[i], arr[j]);
i = j;
j = i * 2 + 1;
} else {
break;
}
}
};
// 建立堆
for (int i = arr.size() / 2 - 1; i >= 0; i--) {
adjustHeap(i, arr.size());
}
// 堆排序
for (int i = arr.size() - 1; i > 0; i--) {
std::swap(arr[0], arr[i]);
adjustHeap(0, i);
}
}
int main() {
std::vector<int> arr {3, 5, 1, 7, 2, 4, 9, 6, 8};
heapSort(arr);
for (int num : arr) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
扫一扫
1192
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
