C++_排序算法：冒泡排序、插入排序、归并排序、快速排序、堆排序、基数排序、桶排序、计数排序

最新推荐文章于 2024-06-27 21:51:33 发布
最新推荐文章于 2024-06-27 21:51:33 发布
阅读量1k 收藏 9
点赞数 1
分类专栏： C++、算法与数据结构 文章标签： c++ 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu798675179/article/details/52105162
版权

C++_排序算法—冒泡、插入、归并、快速、堆、基数、桶、计数

所有代码均可直接运行

需要c++11的支持

冒泡排序：

1、思想：

反复交换相邻的元素以达到排序目的，原址排序，平均和最坏时间复杂度都为Θ(n²)。

2、源代码：

#include <iostream>
#include <vector>
#include <random>

using namespace std;

void Bubble_Sort(vector<long long> &v1) {
	for (auto i = 1; i != v1.size(); ++i) {
		for (auto j = v1.size() - 1; j != i - 1; --j) {
			if (v1[j] < v1[j - 1]) {
				swap(v1[j], v1[j - 1]);
			}
		}
	}
}

vector<long long> Random() {
	static default_random_engine               e;
	static uniform_int_distribution<long long> u(-100000000, 100000000);
	vector<long long>                          v1;

	for (auto i = 0; i != 10000; ++i) {
		v1.push_back(u(e));
	}

	return v1;
}

int main() {
	vector<long long> v1 = Random();
	Bubble_Sort(v1);

	for (auto & i : v1)
		cout << i << " ";

	return 0;
}

插入排序：

1、思想：

从后向前逐个比较，类似于扑克牌的排序 ，原址排序，平均和最坏时间复杂度都为Θ(n²)。

它和冒泡排序的区别是，冒泡是一边比较一边交换元素的位置，而插入则是比较完了再交换元素的位置。也就是说，一个元素交换一次位置下来，冒泡只移动了一个位置，而插入则移动了若干位置。

2、源代码：

#include <random>
#include <iostream>
#include <vector>

using namespace std;

void Insertion_Sort(vector<long long> &v1) {
	long long k;
	long long temp_key;
	for (auto j = 1; j != v1.size(); ++j) {
		temp_key = v1[j];
		k = j - 1;
		while (k >= 0 && v1[k] > temp_key) {
			v1[k + 1] = v1[k];
			--k;
		}
		v1[k + 1] = temp_key;
	}
}

vector<long long> Random() {
	static default_random_engine               e;
	static uniform_int_distribution<long long> u(-100000000, 100000000);
	vector<long long>                          v1;

	for (auto i = 0; i != 10000; ++i) {
		v1.push_back(u(e));
	}

	return v1;
}

int main() {
	vector<long long> v1 = Random();
	Insertion_Sort(v1);

	for (auto &temp : v1) {
		cout << temp << " ";
	}

	return 0;
}

归并排序（二路）：

1、思想：

一分为n，不断递归，排序，再合并，非原址排序，平均和最坏时间复杂度都为Θ(nlgn)。//lg以2为底

2、源代码：

#include <iostream>
#include <vector>
#include <random>

using namespace std;

vector<long long> Random() {
	static default_random_engine               e;
	static uniform_int_distribution<long long> u(-100000000, 100000000);
	vector<long long>                          v1;

	for (auto i = 0; i != 10000; ++i) {
		v1.push_back(u(e));
	}

	return v1;
}

void Merge(vector<long long> &v1, vector<long long> &temp_v, size_t p, size_t q, size_t r) {
	size_t leftEnd = q - 1;
	size_t tempPos = p;
	size_t length = r - p + 1;

	while (p <= leftEnd && q <= r) {
		if (v1[p] <= v1[q])
			temp_v[tempPos++] = v1[p++];
		else
			temp_v[tempPos++] = v1[q++];
	}

	while (p <= leftEnd) {
		temp_v[tempPos++] = v1[p++];
	}

	while (q <= r) {
		temp_v[tempPos++] = v1[q++];
	}

	for (auto i = 0; i != length; ++i, --r) {
		v1[r] = temp_v[r];
	}
}

void Merge_Sort(vector<long long> &v1, vector<long long> &temp_v, size_t p, size_t r) {
	if (p < r) {
		auto q = (p + r) / 2;
		Merge_Sort(v1, temp_v, p, q);
		Merge_Sort(v1, temp_v, (q + 1), r);
		Merge(v1, temp_v, p, (q + 1), r);
	}
}

void Merge_Sort(vector<long long> &v1) {
	vector<long long> temp_v(v1.size());
	Merge_Sort(v1, temp_v, 0, (v1.size() - 1));
}

int main() {
	vector<long long> v1 = Random();
	Merge_Sort(v1);

	for (auto &temp : v1)
		cout << temp << " ";

	return 0;
}

快速排序：

1、思想：

给一个阈值，小于阈值的放前面，大于阈值的放后边，不断递归这个过程。
原址排序，其时间复杂度多半取决于阈值的选取。最坏时间复杂度是Θ(n²)，平均时间复杂度是Θ(nlgn)。//lg以2为底

1、常规化版本：

源代码：

#include <iostream>
#include <random>
#include <vector>

using namespace std;

vector<long long> Random() {
	static default_random_engine               e;
	static uniform_int_distribution<long long> u(-100000000, 100000000);
	vector<long long>                          v1;

	for (auto i = 0; i != 10000; ++i) {
		v1.push_back(u(e));
	}

	return v1;
}

size_t Partition(vector<long long> &v1, size_t p, size_t r) {
	auto i = p - 1;
	for (auto j = p; j != r; ++j) {
		if (v1[j] <= v1[r]) {
			++i;
			swap(v1[i], v1[j]);
		}
	}
	swap(v1[i + 1], v1[r]);

	return i + 1;
}

void Quick_Sort(vector<long long> &v1, long long p, long long r) {
	if (p < r) {
		auto q = Partition(v1, p, r);
		Quick_Sort(v1, p, q - 1);
		Quick_Sort(v1, q + 1, r);
	}
}

void Quick_Sort(vector<long long> &v1) {
	size_t b = 0, e = v1.size() - 1;
	Quick_Sort(v1, b, e);
}

int  main() {
	vector<long long> v1 = Random();
	Quick_Sort(v1);

	for (auto &i : v1) {
		cout << i << " ";
	}

	return 0;
}

2、随机化版本：

随机化版本和普通版本的唯一区别就是，随机化选取阈值。

源代码：

#include <iostream>
#include <random>
#include <vector>

using namespace std;

vector<long long> Random() {
	static default_random_engine               e;
	static uniform_int_distribution<long long> u(-100000000, 100000000);
	vector<long long>                          v1;

	for (auto i = 0; i != 10000; ++i) {
		v1.push_back(u(e));
	}

	return v1;
}

size_t Random_Partition(vector<long long> &v1, size_t p, size_t r) {

	auto ri = p + rand() % (r - p + 1);
	swap(v1[ri], v1[r]);

	auto i = p - 1;
	for (auto j = p; j != r; j++) {
		if (v1[j] <= v1[r]) {
			++i;
			swap(v1[i], v1[j]);
		}
	}
	swap(v1[i + 1], v1[r]);

	return i + 1;
}

void Quick_Sort_Random(vector<long long> &v1, long long  p, long long  r) {
	if (p < r) {
		auto q = Random_Partition(v1, p, r);
		Quick_Sort_Random(v1, p, q - 1);
		Quick_Sort_Random(v1, q + 1, r);
	}
}

void Quick_Sort_Random(vector<long long> &v1) {
	size_t b = 0, e = v1.size() - 1;
	Quick_Sort_Random(v1, b, e);
}

int   main() {
	vector<long long> v1 = Random();
	Quick_Sort_Random(v1);

	for (auto &i : v1) {
		cout << i << " ";
	}

	return 0;
}

堆排序（最大堆）：

1、思想：

堆排序是建立在堆这个数据结构上的。堆又是建立在二叉树上的。最大堆有这样的性质：根节点总比叶结点大，同样，最小堆就是叶结点总比根节点大。
原址排序。最坏时间复杂度为O(nlgn)。//lg以2为底

2、源代码：

#include <iostream>
#include <random>
#include <vector>

using namespace std;

vector<long long> Random() {
	static default_random_engine               e;
	static uniform_int_distribution<long long> u(-100000000, 100000000);
	vector<long long>                          v1;

	for (auto i = 0; i != 10000; ++i) {
		v1.push_back(u(e));
	}

	return v1;
}

void Max_Heapify(vector<long long> &v1, size_t i, size_t length) {
	size_t l = 2 * i + 1;
	size_t r = 2 * i + 2;
	size_t largest = i;

	if (l < length && v1[l] > v1[i]) {
		largest = l;
	}
	if (r < length && v1[r] > v1[largest]) {
		largest = r;
	}
	if (largest != i) {
		swap(v1[i], v1[largest]);
		Max_Heapify(v1, largest, length);
	}
}

void Build_Max_Heap(vector<long long> &v1) {
	for (auto i = v1.size() / 2 - 1; i != -1; --i) {
		Max_Heapify(v1, i, v1.size() - 1);
	}
}

void Heap_Sort(vector<long long> &v1) {
	Build_Max_Heap(v1);
	for (auto i = v1.size() - 1; i != 0; --i) {
		swap(v1[0], v1[i]);
		Max_Heapify(v1, 0, i);
	}
}

int main() {
	vector<long long> v1 = Random();
	Heap_Sort(v1);

	for (auto &i : v1) {
		cout << i << " ";
	}

	return 0;
}

基数排序：

1、思想：

其是一种卡片机上的排序算法，给定n个有d位的整数，其中每一位数都有k个可能的取值，从低位到高位，依次排序。
例如有n组日期（年、月、日），先排日期，再月，最后是年。
原址排序。最坏和平均时间复杂度都为Θ(d (n + k))。

2、源代码：

//Tan Chuanqi's thought.   chuanqi.tan@gmail.com

#include <iostream>
#include <vector>
#include <random>
#include <algorithm>

using namespace std;

vector<long long> Random() {
	static default_random_engine               e;
	static uniform_int_distribution<long long> u(0, 99999);
	vector<long long>                          v1;

	for (auto i = 0; i != 10000; ++i) {
		v1.push_back(u(e));
	}

	return v1;
}

auto max_dim = 5;

void Radix_Sort(vector<long long> &v1, long long dim) { 
	stable_sort(v1.begin(), v1.end(), [&dim](long long temp_1, long long temp_2) {
		auto Dim_Num = [](long long &temp_num, long long &d) -> long long {
			for (auto i = 1; i <= max_dim - d; ++i) {
				temp_num /= 10;
			}
			return temp_num % 10;
		};
		return Dim_Num(temp_1, dim) < Dim_Num(temp_2, dim);
	});

	if (dim != 1) {
		Radix_Sort(v1, dim - 1);
	}
}

int main() {
	vector<long long> v1 = Random();
	Radix_Sort(v1, max_dim);

	for (auto &i : v1) {
		cout << i << " ";
	}

	return 0;
}

桶排序：

1、思想：

桶排序将[0，1)区间划分为n个大小相同的子区间，或称为桶。然后将n个数分别放入各个桶中。再对各个桶中的数据分别排序。最后再将各个桶中的数据合并。
非原址排序。最坏时间复杂度为Θ(n²)，平均时间复杂度为Θ(n)。

2、源代码：

#include <iostream>
#include <vector>
#include <random>
#include <algorithm>

using namespace std;

vector<double> Random() {
	static default_random_engine             e;
	static uniform_real_distribution<double> u(0, 1);
	vector<double>                           v1;

	for (auto i = 0; i != 10000; ++i) {
		v1.push_back(u(e));
	}

	return v1;
}

void Bucket_Sort(vector<double> &v1) {
	vector<vector<double>> bucket(10);

	for (auto &i : v1) {
		bucket[10 * i].push_back(i);
	}

	for (auto &i : bucket) {
		stable_sort(i.begin(), i.end());
	}

	v1.clear();

	for (auto &i : bucket) {
		v1.insert(v1.end(), i.begin(), i.end());
	}
}

int main() {
	vector<double> v1 = Random();
	Bucket_Sort(v1);

	for (auto &i : v1) {
		cout << i << " ";
	}

	return 0;
}

计数排序：

1、思想：

假设n个输入元素中的每一个都是在0到k区间的整数，对于元素x，计算出小于x的元素个数s，那么排序后x的位置为s+1（以0为首位置的数组，元素位置依然为s）。
它和之前所讲的排序最大不同就是，它不是比较，而是计算，但是，它有致命弱点，所排序值必须小于数组下标的最大值，并且只能排自然数。
非原址排序。最坏和平均时间复杂度都为Θ(k + n)。

2、源代码：

#include <iostream>
#include <vector>
#include <random>

using namespace std;

vector<long long> Random() {
	static default_random_engine               e;
	static uniform_int_distribution<long long> u(0, 99999);
	vector<long long>                          v1;

	for (auto i = 0; i != 100000; ++i) {
		v1.push_back(u(e));
	}

	return v1;
}

void Counting_sort(vector<long long> &v1) {
	vector<long long> temp_v1 = v1;
	vector<long long> temp_count(v1.size(), 0);

	for (auto &j : v1) {
		++temp_count[j];
	}

	for (auto i = 1; i != temp_count.size(); ++i) {
		temp_count[i] += temp_count[i - 1];
	}

	for (auto j = v1.size() - 1; j != -1; --j) {
		temp_v1[temp_count[v1[j]] - 1] = v1[j];
		--temp_count[v1[j]];
	}

	v1 = temp_v1;
}

int main() {
	vector<long long> v1 = Random();
	Counting_sort(v1);

	for (auto &i : v1) {
		cout << i << " ";
	}

	return 0;
}
_MICHAEL_LIU_
关注
专栏目录
C++ 计数排序
辛旭东小小工作室
03-15 1001
计数排序的原理： （1）首先，找出最大的元素，给“count[ ]”申请“最大元素的下标+1”个单元(因为数组下标是从0开始的，所以要+1)； （2）然后，统计每个元素出现的次数，把次数存到“count[ ]”里； （3）最后，通过一个元素出现的次数-1，从而算出正确顺序的位置，再把元素放进去，就有顺序了。 因为不知道范围的大小，所以需要申请内存，如果知道范围的大小，就可以直接声明。 ...
计数排序 C++
aganghaizai的博客
08-08 556
计数排序适用的应用场景： 量大但是范围小（全省高考成绩、某大型企业数万名员工年龄的排序） 且知道范围（例如成绩满分和零分 年龄0岁到150岁） 方法： 1、创建另外一个数组用于*计数***，数组的大小则为数值范围加1 （0~100）则数组长度为100-0+1 = 101； 因为我们要用数组的索引值（下标）作为每一个数值所对应的“家”**斜体样式 正好从0开始到100； 2、接着我们遍历原数组，每次读到与计数数组的下标值一样的数值时，则对计数数组改下标所对应的数组值加1（count[ nums[0] ]+
常用排序算法C++实现（堆排序，快速排序，归并排序，基数排序）
u010662460的专栏
11-30 629
常用排序算法C++实现（堆排序，快速排序，归并排序，基数排序）
C++实现排序之基数排序
最新发布
Shenmmm的博客
06-27 533
基数排序（Radix Sort）是一种非比较型的排序算法，其基本原理是将整数按位数分配，然后按每个位数进行排序。基数排序的稳定性以及时间复杂度与输入数据的分布有关。提示：这里对文章进行总结：例如：以上就是今天要讲的内容，本文仅仅简单介绍了基数排序使用，而基数排序算是c++中较难的排序。
计数排序----C++
qq_42036661的博客
12-06 382
emmmC++真的有些绝望，在实现上要比Java难 计数排序： 其核心思想是选择。 温故--选排： 我们知道，选择排序是第n次选出第n大的值放在a[n-1]（数组从0开始，若为n个元素，则最后一个为a[n-1]）的位置---即数组的最大值放在a[0],第二大放a[1]...第n大在a[n-1]. 上一篇博客有写。链接：https://mp.csdn.net/postedit/845931...
c++排序: 冒泡、选择、插入、归并、快速、堆排序、桶排序
bitdai2018
12-04 276
排序 github源码地址 文章目录排序一、冒泡排序二、选择排序三、插入排序四、归并排序：左排右排合并五、快速排序：分区递归六、堆排序：堆头交换下树循环堆上树下树堆排序七、桶排序计数排序基数排序补充：应用归并排序：最小和&逆序对快速排序：荷兰国旗问题桶排序：计算数组排序后的相邻两数的最大差值综合排序 最优解：先满足时间复杂度最优，再满足最小空间 稳定性：相同元素在排序时的先后位置不变 递归...
C++排序算法（冒泡排序，选择排序，归并排序，快速排序）
YK_LaNce的博客
03-19 409
冒泡排序 选择排序 归并排序 快速排序
八大排序C++完整代码（冒泡、希尔、插入、选择、快排、归并、桶、堆）
12-30
本资源提供了八大经典排序算法的C++实现，包括冒泡排序、希尔排序、插入排序、选择排序、快速排序、归并排序、桶排序以及堆排序。接下来，我们将深入探讨这些排序算法的原理、效率以及它们在C++中的实现。 1. **...
C++不知算法系列之排序从玩转冒泡算法开始
12-29
冒泡排序、插入排序和归并排序是稳定的，而快速排序、堆排序、选择排序和希尔排序则不稳定。 【冒泡排序算法的实现】通常包含两个主要步骤： 1. **遍历数列**：从第一个元素开始，逐个比较相邻元素，如果顺序错误则...
快速排序等经典排序算法C++、Java、python等版本
09-29
常见的排序算法有多种，包括【冒泡排序】、【插入排序】、【选择排序】、【希尔排序】、【计数排序】、【基数排序】、【桶排序】、【快速排序】、【归并排序】和【堆排序】。这些算法根据不同的工作原理和性能特点被...
C++实现各种排序算法.zip
10-11
8. **计数排序（Counting Sort）、桶排序（Bucket Sort）和基数排序（Radix Sort）**：这些属于非比较型排序，不依赖元素之间的比较，而是根据特定属性（如计数值、分布范围或位数）进行排序，适用于特定类型的数据...
C++10大排序算法PPT及代码示例，视频动图演示
06-27
10. **桶排序**（Bucket Sort）是另一种非基于比较的排序算法，适用于数据分布均匀的情况。将数据分到有限数量的桶里，每个桶再分别排序，最后把所有桶里的数据合并。其时间复杂度可达到线性O(n + k)，但依赖于数据...
C++计数排序
m0_61033277的博客
07-25 411
基数排序（英语：Radix sort）是一种非比较型的排序算法，最早用于解决卡片排序的问题。它的工作原理是将待排序的元素拆分为k个关键字（比较两个元素时，先比较第一关键字，如果相同再比较第二关键字……），然后先对第k关键字进行稳定排序，再对第k-1关键字进行稳定排序，再对第k-2关键字进行稳定排序……最后对第一关键字进行稳定排序，这样就完成了对整个待排序序列的稳定排序。...
排序-计数排序
perye
06-30 222
计数排序简介工作原理性质稳定性时间复杂度代码实现计数排序倒序遍历的计数排序 计数排序 简介 计数排序（Counting sort）是一种线性时间的排序算法。 工作原理 计数排序的工作原理是使用一个额外的数组 CCC，其中第 iii 个元素是待排序数组 AAA 中值等于 iii 的元素的个数，然后根据数组 CCC 来将 AAA 中的元素排到正确的位置。 它的工作过程分为三个步骤： 计算每个数出现了几次； 求出每个数出现次数的 前缀和； 利用出现次数的前缀和，从右至左计算每个数的排名。 性质 稳定性 计数.
c++计数排序
一位小学生的博客
07-27 323
c++计数排序
c++——计数排序
tzj511427的博客
06-03 266
计数排序
C++实现计数排序
luanzheng_365的博客
06-25 386
计数排序首先利用数组计数器count[]对每个数字在数组data[]中出现的次数进行计数.然后,计数器将所有<=i的整数的个数添加并存储到count[i]中.通过这种办法,count[i]-1表明i在data[]中的主位置.时间复杂度: 4*max value 空间复杂度: O(n),需要额外计数器存储与额外最终排序空间存储,即不是在原有数组上进行排序. 算法稳定性: 稳定补充强化C++基础,c
C++实现排序算法类全览：从插入到归并
本资源提供了多种经典的排序算法的C++类实现，包括直接插入排序、折半插入排序、Shell排序、归并排序、简单选择排序、基数排序以及堆排序等。以下将详细讲解这些排序算法的原理和C++实现。 1. **直接插入排序...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值