十大排序算法C++实现

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

1、插入排序：和玩纸牌游戏一样，抓牌时小的插在前边，后边牌往后移动

void insertSort(int* arr, int len){
   if(!arr || len<2)
       return;
   int preIndex=0, curVal=0;
   for(int i=1; i<len; i++){
       preIndex = i - 1;
       curVal = arr[i];
       while(preIndex>=0 && arr[preIndex]>curVal){
          arr[preIndex+1] = arr[preIndex];
          preIndex--;
       }
       arr[preIndex+1] = curVal;
   }
}

2、冒泡排序：它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成

void bubbleSort(size_t size, int* arr) {
	if (!arr || size <= 1) {
		return;
	}

	bool bComplete = false;
	for (size_t i = 0; i < size; i++) {
		bComplete = true;
		for (size_t j = 0; j < size - i - 1; j++) {
			if (arr[j] > arr[j + 1])
			{
				std::swap(arr[j], arr[j + 1]);
				bComplete = false;
			}
		}
		if (bComplete) {
			return;
		}
	}
}

3、选择排序：选择排序是一种简单直观的排序算法
首先，在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾
以此类推，直到所有元素均排序完毕

void selectSort(size_t size, int* arr) {
	if (!arr || size <= 1) {
		return;
	}

	size_t minIndex = 0;
	for (size_t i = 0; i < size - 1; i++) {
		minIndex = i;
		for (size_t j = i + 1; j < size; j++) {
			if (arr[j] < arr[minIndex]) {
				minIndex = j;
			}
		}
		std::swap(arr[i], arr[minIndex]);
	}
}

4、希尔排序：是简单插入排序的改进版，它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

void shellSort(size_t size, int*arr) {
	if (!arr || size <= 1) {
		return;
	}

	size_t gap = 1;
	size_t j = 0;

	//固定增量变化
	for (gap = size / 2; gap > 0; gap /= 2) {
		for (size_t i = gap; i < size; ++i) {
			//int()转换类型，避免溢出，相当于分组的插入排序
			for (j = i; int(j - gap) >= 0 && arr[j - gap] > arr[j]; j -= gap) {
				std::swap(arr[j - gap], arr[j]);
			}
		}
	}
}

5、归并排序

void merge(int*arr, size_t left, size_t mid, size_t right) {
	int len = right - left + 1;
	int *temp = new int[len];  //数组较长时请用new，不然栈空间容易溢出
	size_t index = 0;
	size_t i = left, j = mid + 1;
	while (i <= mid && j <= right){
		temp[index++] = arr[i] <= arr[j] ? arr[i++] : arr[j++]; //对两边的数组从小到大放入临时空间
	}
	while (i <= mid){
		temp[index++] = arr[i++];//比较完后，左半边有没放进去的，直接写入
	}
	while (j <= right)	{
		temp[index++] = arr[j++];//比较完后，右半边有没有放进去的，直接写入
	}

	for (int k = 0; k < len; ++k){
		arr[left++] = temp[k];  //把有序的临时数组写入原来数组的起始位置
	}
	delete[] temp;  //释放空间
	temp = NULL;  //指针置空
}

void divide(int* arr, size_t left, size_t right) {
	//递归出口
	if (left == right){
		return;
	}
	size_t mid = (left + right) / 2; //找出区间中部的数，将数组分段
	divide(arr, left, mid);//递归调用，对左边继续分段；
	divide(arr, mid + 1, right);//递归调用，对左边继续分段；
	merge(arr, left, mid, right); //对左右两半进行排序合并成一小段有序的数组
}


void mergeSort(size_t size, int* arr) {
	if (!arr || size <= 1) {
		return;
	}

	size_t left = 0, right = size - 1;
	divide(arr, left, right);
}

6、快速排序：每次都取数组的第一个元素作为基准元素，凡是大于这个基准元素的都放在右边，凡是小于这个基准元素的都放在它的左边。

  • 设置两个变量i,j（称为哨兵），令序列的第一个元素为基准元素。
  • i指向序列的最左边， j指向序列的最右边，j从右往左试探，i从左往右试探，直到j找到小于基准的数就停止，i找到大于基准的数就停止，交换i和j指向的两个数，j继续往左试探，i继续往右试探
  • 如果i和j相遇，则i或j上的元素与基准元素交换，一轮排序结束
  • 对基准元素两边的序列重复上述步骤
void qSort(int* arr, int left, int right) {
	int i = left;
	int j = right;
	int temp = arr[left]; //基准元素

	//递归结束条件
	if (left >= right) {
		return;
	}

	while (i != j) {
		while (arr[j] >= temp && i < j) { //从右往左，找到小于基准的数
			j--;
		}
		while (arr[i] <= temp && i < j) { //从左往右，找到大于基准的数
			i++;
		}
		//交换i和j指向的两个数，然后继续，知道i,j相遇
		if (i < j) {
			std::swap(arr[i], arr[j]); 
		}
	}
	//i和j相遇，i 或 j上的元素与基准元素交换，一轮排序结束
	arr[left] = arr[i]; 
	arr[i] = temp;
	//再分别对两边数据递归快排
	qSort(arr, left, i - 1);
	qSort(arr, i + 1, right);
}

void quickSort(size_t size, int* arr) {
	if (!arr || size <= 1) {
		return;
	}

	qSort(arr, 0, size - 1);
}

7、堆排序

//建立大堆(1、完全二叉树；2、父节点的值始终大于子节点)
void heapify(int* tree, int n, int i) {
	//递归结束出口
	if (i >= n) {
		return;
	}
	int left = 2 * i + 1;
	int right = 2 * i + 2;
	int maxIndex = i;
	maxIndex = (left < n && tree[left] > tree[maxIndex]) ? left : maxIndex;
	maxIndex = (right < n && tree[right] > tree[maxIndex]) ? right : maxIndex;
	if (maxIndex != i) {
		std::swap(tree[i], tree[maxIndex]);
		heapify(tree, n, maxIndex);
	}
}

void heapSort(int size, int* arr) {
	if (!arr || size <= 1) {
		return;
	}

	int lastNodeIndex = size - 1; //最后一个子节点
	int lastParentIndex = (lastNodeIndex - 1) / 2; //最后一个子节点的父节点
	//从最后一个子节点的父节点开始对所有父节点建立大堆
	for (int i = lastParentIndex; i >= 0; i--){
		heapify(arr, size, i);
	}

	//经过上一步骤处理后根节点必然是最大的值
	//将根节点和最后一个子节点交换位置后截取掉树的最后一个节点，也就是最大的值，这时大堆被打乱，再对树中剩下的值heapify
	for (int i = size - 1; i >= 0; i--) {
		std::swap(arr[i], arr[0]);
		heapify(arr, i, 0);
	}
}

8、计数排序

void countSort(int size, int* arr) {
	if (!arr || size <= 1) {
		return;
	}

	int index = 0, min, max;
	min = max = arr[0];

	//遍历数组找出最小和最大的数  5  3  4  7  2  4  3  4  7
	for (size_t i = 1; i < size; i++) {
		min = arr[i] < min ? arr[i] : min;
		max = arr[i] > max ? arr[i] : max;
	}

	int len = max - min + 1;
	int* temp = new int[len](); //初始化为0

	for (int i = 0; i < size; i++) {
		temp[arr[i] - min]++;
	}

	//打印下计数数组
	for (int i = 0; i < len; i++)
	{
		std::cout << temp[i] << " ";
	}
	std::cout << std::endl;


	for (int i = min; i <= max; i++)
	{
		int count = temp[i - min];
		for (int j = 0; j < count; ++j)	//存放元素个数不为0的，才进入循环
		{
			arr[index++] = i;  //把元素值写回数组
		}
	}
	delete[] temp;
	temp = nullptr;
}

9、桶排序，将数据按规则分组，对各小组再分别排序

  • 数组长度一定的，只申请一次内存，避免内存碎片化，提高效率
  •  给定桶的个数，程序运行状况在不同环境下可控
void bucketSort(size_t size, int *arr, int bucketCount = 10)
{
	if (!arr || size <= 1) {
		return;
	}

	int maxval = arr[0];
	int minval = arr[0];
	//遍历数组，找出最大最小元素
	for (int i = 0; i != size; ++i)	{
		maxval = maxval > arr[i] ? maxval : arr[i];
		minval = minval < arr[i] ? minval : arr[i];
	}
	//如果最大等于最小，数组不需要排序
	if (maxval == minval){
		return;
	}

	int div = /*1000*/bucketCount; //桶的个数
	int space = (maxval - minval) / div + 1; //每个桶的数值跨度，+1放大一点包住
	int *numsofeachbucket = new int[div](); //开辟数组，存放每个桶内的元素个数，（）初始化为0
	int *endpositionofeachbucket = new int[div]();
	for (size_t i = 0; i != size; ++i){
		//把元素按大小分到不同的桶，并增加该桶元素个数
		numsofeachbucket[(arr[i] - minval) / space]++;
		endpositionofeachbucket[(arr[i] - minval) / space]++;
	}
	for (int i = 1; i != div; ++i){
		endpositionofeachbucket[i] += endpositionofeachbucket[i - 1];
		//每个桶区间的最大下标+1的值
	}
	int *temp = new int[size];	//开辟堆空间，存放临时数组
	for (size_t i = 0; i != size; ++i){
		temp[--endpositionofeachbucket[(arr[i] - minval) / space]] = arr[i];
		//遍历数组，把每个元素写入对应的桶中，从每个桶的后部往前写
		//--运行完成后endpositionofeachbucket[i]就是该桶的首位
	}
	for (size_t i = 0; i != div; ++i)
	{
		if (numsofeachbucket[i] > 1)	//桶元素2个或以上才排序
		{
			//对每个桶的数组进行快速排序（元素个数，每个桶数组首位的地址）
			quickSort(numsofeachbucket[i], &temp[endpositionofeachbucket[i]]);
		}
	}

	//对排序后的数组，写入原数组
	for (size_t i = 0; i != size; ++i){
		arr[i] = temp[i];
	}
	delete[] numsofeachbucket;
	delete[] endpositionofeachbucket;
	delete[] temp;
	numsofeachbucket = nullptr;
	endpositionofeachbucket = nullptr;
	temp = nullptr;

}

10、基数排序

void radix_countsort(size_t size, int *arr, int exp)
{
	int numofeachbucket[10] = { 0 };  //十个数位，每个桶上有0个元素
	for (int i = 0; i != size; ++i) {
		++numofeachbucket[(arr[i] / exp) % 10];	//记录该数位上相同的元素个数
	}

	for (int i = 1; i < 10; ++i) {
		numofeachbucket[i] += numofeachbucket[i - 1];
	}

	int *temp = new int[size];
	for (int i = size - 1; i >= 0; --i) {
		int k = (arr[i] / exp) % 10;
		temp[numofeachbucket[k]] = arr[i]; //把数组放在不同的区间位置上
		numofeachbucket[k]--;
	}

	for (int i = 0; i != size; ++i) {
		arr[i] = temp[i];  //一个数位排好后，写回原数组，开始下一位数的装桶排序
	}

	delete[] temp;
	temp = nullptr;
}

void radixSort(size_t size, int *arr)
{
	if (!arr || size <= 1) {
		return;
	}

	int max = arr[0];
	//找出最大的数
	for (size_t i = 0; i != size; ++i) {
		max = arr[i] > max ? arr[i] : max;
	}
	//从最低位开始对每个数位进行排序
	for (int exp = 1; max / exp > 0; exp *= 10) {
		radix_countsort(size, arr, exp);
	}
}

 

IT集装箱
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++基础进阶：提取txt文件中的数字，并且排序
weixin_44317873的博客
10-18 1658
这个问题是比较难的，涵盖了C++中的，宏定义，容器类中vector,C++结构体的使用，C++进阶时最常用到的迭代器（这个是你做项目上经常会用到的）。
十大经典排序算法（C++实现）
m0_60935443的博客
03-22 9071
0、算法分类 排序算法是《数据结构与算法》中最基本的算法之一。 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，时间复杂度为 O(nlogn)～O(n²)。 非比较类排序：不通过比较来决定元素间的相对次序，其时间复杂度可以突破 O(nlogn)，以线性时间运行。 名次解释： 时间/空间复杂度：描述一个算法执行时间/占用空间与数据规模的增长关系。 n：待排序列的个数。 k：“桶”的个数（上面的三种非比较类排序都是基于“桶”的思想实
十大排序算法（C++）
沉默、凝视的博客
02-21 577
十大排序算法（C++） 1、冒泡排序 原理：比较相邻两个元素，如果前一个比后一个大则交换二者位置（以升序为例），每进行一轮比较则可以把最大的元素放到相对最后的位置。每进行一轮比较就会有一个元素变为有序。循环对每轮越来越少的元素进行比较则最终变为有序序列。 如果序列元素初始时为有序，则一轮则可进行排序完毕，最好时间复杂度为O(n)；如果序列元素初始时是逆序，则需要n-1轮比较，且每轮要进行n-i次比较，最坏时间复杂度为O(n²)，平均时间复杂度为O(n²)。 // 冒泡排序 void SortBubblin
排序算法总结(一)
xiao_Hebut的博客
09-04 312
0排序算法说明 0.1排序的定义 对一序列对象根据某个关键字进行排序 0.2 术语说明 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面； 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面； 内排序：所有排序操作都在内存中完成； 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行； 时间复杂度：一个算法执行所耗费...
十大排序算法c++实现_fish.rar
05-06
十大排序算法c++实现，建议结合下面这篇文章看 ...
十大排序算法的c++程序实现
05-26
十大排序算法的c++程序实现
C++十大排序算法代码
08-09
C++十大排序算法代码
几个排序算法的C++实现
最新发布
02-03
本项目提供了几个经典的排序算法的C++实现，有助于理解这些算法的工作原理以及如何在实际编程中应用它们。 1. **冒泡排序（Bubble Sort）**： 冒泡排序是一种简单的排序算法，通过不断交换相邻的逆序元素来逐渐把...
考研排序算法C++实现
11-02
考研排序算法C++实现
七大排序算法c++实现
10-03
七大排序算法C++实现，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序。代码随机生成数组来排序，MAX1定义了数组个数，用QueryPerformanceCounterday打印除了各算法用时。
常见的十种排序算法（C++下实现）
shililia的博客
07-27 542
常见的十种排序算法（C++下实现） 前言 排序算法是比较常见的一种算法，这里笔者给出十种排序算法在C++下的实现，并结合资料作一个简单的概括。 源码地址：https://github.com/Z-Li-Jie/Sorts 概括 1、 内排序和外排序 根据在排序过程中待排序的记录是否全部被放置在内存中，排序分为：内排序和外排序。 内排序是在排序整个过程中，待排序的所有记录全部放置在内存中。外排序是由于排序的记录个数太多，不能同时放置在内存，整个排序过程需要在内外存之间多次交换数据才能进行。笔者在这里主要.
c/c++函数返回数组
walter 的博客
12-17 3541
c++函数如何返回一个数组调用某个函数时经常需要函数返回一个值，我们都知道c++ 的函数返回的是一个copy，所以当只返回一个值时不会出现什么问题，直接return一个copy就行了，但是如果返回一个数组，事情就变得有趣了，我最近就遇到了这个问题。先附上代码吧：#include<iostream>using namespace std;//函数声明 int * fun1();int * fun2()
十大排序算法大总结C++实现
qq_40059236的博客
07-06 311
最近为了熟悉经典的排序算法，我又进行了复习总结，实现过程全部由C++完成。代码结构清晰简洁，方便学习和复习，也是我们必须掌握的基础。
七大常用查找算法C++实现
lvchang
08-07 1143
1、顺序查找 int sequenceSearch(int* arr, int size, int n) { if (!arr || size<1){ return -1; } for (int i=0; i!=size; ++i){ if (n = arr[i]){ return i; } } return -1; } 2、二分查找-非递归 int binarySearch(int* arr, int size, int n) { if (!arr ||.
C++实现十大排序算法（冒泡排序、选择排序、插入排序、希尔排序、归并排序、堆排序、快速排序、计数排序、桶排序和基数排序）
徐丨若木
09-22 1759
目录 0 概述 1 冒泡排序 2 选择排序 3 插入排序 4 希尔排序 5 归并排序 6 堆排序 7 快速排序 8 计数排序 9 桶排序 10 基数排序 本文为C++实现的十大排序算法及基于排序算法解决的一些常见问题，每一种算法均实际运行，确保正确无误。文中内容为自己的一些理解，如有错误，请大家指正。 0 概述 在十种排序算法中，前七种是比较类排序，后三种是非比较类排序，每种算法的最好、最坏、平均时间复杂度，空间复杂度以及稳定性如下表所示。稳定性是指排序前后相等的元素相对位置保.
常用排序算法以及算法性能测试(完整C/C++代码实现)
菜鸡逆袭的博客
07-02 3856
排序算法的比较 注: 由于只是测试算法性能, 所以不会对排序算法做深入讲解, 在随后的时间将会推出排序的详细讲解 问题需求分析 排序算法经过了很长时间的演变，产生了很多种不同的方法。每种算法主要针对不同的数列进行排序，这些排序算法具有各自的利弊，并且应用的场景各自不同，为了针对不同的场景选出最合适的排序算法，接下来将使用大量随机数列，以及不同的数据场景对不同的排序算法进行比较，最终找出排序算法各自...
十大排序算法的实现c++
08-31
对于十大排序算法中的堆排序、选择排序和冒泡排序算法的C语言实现，可以参考如下代码： 堆排序： ```c void heapify(int *vec, int i, int len) { int left = i * 2 + 1; int right = i * 2 + 2; int largest = i; if (left < len && vec[left > vec[largest]) { largest = left; } if (right < len && vec[right > vec[largest]) { largest = right; } if (largest != i) { int temp = vec[i]; vec[i = vec[largest]; vec[largest = temp; heapify(vec, largest, len); } } void heapSort(int *vec, int len) { for (int i = len / 2 - 1; i >= 0; i--) { heapify(vec, i, len); } for (int j = len - 1; j > 0; j--) { int temp = vec = vec[j]; vec[j = temp; heapify(vec, 0, j); } } ``` 选择排序： ```c void selectionSort(int *vec, int len) { for (int i = 0; i < len - 1; i++) { int minIndex = i; for (int j = i + 1; j < len; j++) { if (vec[j < vec[minIndex]) { minIndex = j; } } if (minIndex != i) { int temp = vec[i]; vec[i = vec[minIndex]; vec[minIndex = temp; } } } ``` 冒泡排序： ```c void bubbleSort(int *vec, int len) { for (int i = 1; i < len; i++) { for (int j = 0; j < len - i; j++) { if (vec[j > vec[j + 1]) { int temp = vec[j]; vec[j = vec[j + 1]; vec[j + 1 = temp; } } } } ``` 这些代码分别实现了堆排序、选择排序和冒泡排序算法，可以通过传入一个整型数组和数组长度来对数组进行排序。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [用C++实现十大经典排序算法](https://blog.csdn.net/qq_34139994/article/details/128217009)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.239^v12^insert_chatgpt"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值