C++八大排序代码 纯代码+复杂度 稳定性总结

已于 2022-07-28 11:49:22 修改
阅读量219 收藏
点赞数
文章标签： 排序算法 算法 数据结构 c++
于 2022-06-09 10:45:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51164515/article/details/125198972
版权

C++八大排序代码

欢迎使用Markdown编辑器

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
//稳定性： 两个相等的值 A和A`  如果排序开始前 A在A`的前面   排序后A还在A`的前面 则这个排序算法稳定
//怎么判断是否稳定？    看这个算法里面是否有跳跃交换   
/*八大排序：
1.冒泡排序：两两比较，大的向后挪动  //时间复杂度O（n^2） 空间复杂度O（1）    稳定性：稳定
2.简单选择排序：每一轮找到待排序序列的最小值和待排序序列的第一个值进行交换   //时间复杂度O（n^2）   空间复杂度O（1）   稳定性：不稳定
3.直接插入排序：依次从待排序序列中取值，向已排序排序中放，保证再次完全有序，直到将待排序序列中所以值取完 //时间复杂度O（n^2）  空间复杂度O（1）  稳定性：稳定
4.希尔排序：shell排序，缩小增量排序，对于直接插入排序的优化，每一次让数据变得更加稳定，直到增量为1的时候，彻底完全有序  //时间复杂度O（n^1.3~1.5）  空间复杂度O（1）    稳定性：不稳定
5.二路归并排序：首先将所有的数组看做单独的个体，然后依次合并，直到将所有的数据融合在一组，则停止   //时间复杂度 O（nlogn）  空间复杂度（nlogn）  稳定性：稳定
6.基数排序：将所有数据从左向右，依次按照低位优先，全部进入到桶内，再从桶内取出      //时间复杂度O（dn） 空间复杂度O(dn) 稳定性：稳定
7.堆排序，如果需要升序排序，则需要大顶堆，则将去数据调整为大顶堆，再将根节点和最后一个已知节点交换，然后重复此操作，直到剩余一个节点     //时间复杂度O（nlogn）   空间复杂度O（1）  稳定性：不稳定
8：快速排序，重复划分，找基准值，将小于基准值的值全部放在左边，大于基准值的值全部放在右边：从右向左找比arr[left]更小的值，再从左向右找比arr[right]更大的值放过去，重复此操作，只能left>=right 退出   //快排，是每一次将基准值放到合适位置上   时间复杂度O（nlogn） 空间复杂度O（logn）  稳定性：不稳定
*/
/*
四个稳定：冒泡 直接插入排序  二路归并排序 基数排序
四个不稳定：简单选择排序 希尔排序
*/

//时间复杂度O（n^2） 空间复杂度O（1）    稳定性：稳定
//缺点：时间复杂度大   优点：实现简单  稳定
void BubbleSort(int* arr, int len)
{
	//assert

	for (int i = 0; i < len - 1; i++)//控制轮数
	{
		for (int j = 0; j < len - 1 - i; j++)//控制每一轮比较的次数
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

void Show(int* arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

//时间复杂度O（n^2）   空间复杂度O（1）   稳定性：不稳定
void SelectSort(int* arr, int len)
{
	//assert
	int minindex;//保存最小值的下标，而不是最小值本身

	for (int i = 0; i < len - 1; i++)//控制层数
	{
		minindex = i;
		for (int j = i + 1; j < len; j++)//找到这一轮待排序序列的最小值的下标
		{
			if (arr[j] < arr[minindex])
			{
				minindex = j;
			}
		}
		//第二层for循环执行结束  可以确定待排序序列中最小值的下标 保存在 minindex里
		//arr[minindex] arr[i]
		if (minindex != i)  //
		{
			int tmp = arr[minindex];
			arr[minindex] = arr[i];
			arr[i] = tmp;
		}

	}

}

void Swap1(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void Swap2(int* a, int* b)
{
	*a = *a + *b;
	*b = *a - *b;
	*a = *a - *b;
}

void Swap3(int* a, int* b)
{
	*a = *a ^ *b;
	*b = *a ^ *b;
	*a = *a ^ *b;
}
void Reverse(int* arr, int len)
{
	int i = 0;
	int j = len - 1;

	while (i <= j)
	{
		Swap1(&arr[i], &arr[j]);
		i++;
		j--;
	}
}

int count = 0;
//时间复杂度O（n^2）  空间复杂度O（1）  稳定性：稳定
void InsertSort(int arr[], int len)
{
	int tmp = 0;
	int j;//j代表的是已排序序列中需要和tmp比较的值
	for (int i = 1; i <= len - 1; i++)//i代表的是未排序序列中此次需要插入的值（变稳定）
	{
		tmp = arr[i];
		for (j = i - 1; j >= 0; j--) //j代表的是已排序序列中需要和tmp比较的值   依次和tmp比较
		{
			if (arr[j] > tmp)//如果arr[j]的值大于tmp   向右挪动一个格子
			{
				arr[j + 1] = arr[j];
				count++;
			}
			else//如果arr[j]的值小于等于tmp   break  因为此时arr[j+1]就是tmp应该放的位置
			{
				break;
			}
		}
		//此时已排序排序已经比较完毕    此时的j+1这个位置  将tmp放进去即可
		arr[j + 1] = tmp;
	}

}

//先写 写完可以讨论  9点我来写
void Shell(int arr[], int len, int gap)
{
	int tmp = 0;
	int j;//j代表的是已排序序列中需要要tmp比较的值
	for (int i = gap; i < len; i++)
	{
		tmp = arr[i];
		for (j = i - gap; j >= 0; j -= gap)
		{
			if (arr[j] > tmp)
			{
				arr[j + gap] = arr[j];
				count++;
			}
			else
			{
				break;
			}
		}
		//此时 内层for退出，代表着tmp最终的位置已经找到
		arr[j + gap] = tmp;
	}
}


//时间复杂度O（n^1.3~1.5）(和增量数组取值有关)  空间复杂度O（1）    稳定性：不稳定
void ShellSort(int* arr, int len)
{
	int brr[] = { 13,11,7,5,3,1 };
	int len_brr = sizeof(brr) / sizeof(brr[0]);//3
	for (int i = 0; i < len_brr; i++)
	{
		Shell(arr, len, brr[i]);
	}
}



//int main()
//{
//	int arr[] = {2,1,3,9,8,7};
//	//BubbleSort(arr, sizeof(arr)/sizeof(arr[0]));
//	SelectSort(arr, sizeof(arr)/sizeof(arr[0]));
//	Show(arr, sizeof(arr)/sizeof(arr[0]));
//
//	int brr[] = {1,2,3,4,5,6,7,8,9,10,11};
//	Reverse(brr, sizeof(brr)/sizeof(brr[0]));
//	Show(brr, sizeof(brr)/sizeof(brr[0]));
//	/*int a = 10;
//	int b = 20;
//
//	Swap2(&a, &b);
//	printf("%d %d\n", a, b);*/
//	return 0;
//}


//根据传递进来的gap进行几几合并
static void Merge(int* arr, int len, int gap)
{
	//因为数据本身空间不够用  所以一进来申请一个和数组等长的动态内存
	int* brr = (int*)malloc(sizeof(int) * len);
	assert(brr != NULL);


	int L1 = 0;
	int H1 = L1 + gap - 1;
	int L2 = H1 + 1;
	int H2 = L2 + gap - 1 < len ? L2 + gap - 1 : len - 1;
	int i = 0;//i代表brr的下标

	while (L2 < len)
	{
		while (L1 <= H1 && L2 <= H2)
		{
			if (arr[L1] <= arr[L2])
			{
				brr[i++] = arr[L1++];
			}
			else
			{
				brr[i++] = arr[L2++];
			}
		}

		while (L1 <= H1)//如果左边组还有数据，挪下来
		{
			brr[i++] = arr[L1++];
		}
		while (L2 <= H2)//如果右边组还有数据，挪下来
		{
			brr[i++] = arr[L2++];
		}

		L1 = H2 + 1;
		H1 = L1 + gap - 1;
		L2 = H1 + 1;
		H2 = L2 + gap - 1 < len ? L2 + gap - 1 : len - 1;
	}
	while (L1 < len)//如果左边组还有数据，挪下来
	{
		brr[i++] = arr[L1++];
	}
	//此时，调整后的数据全部在brr 内

	//重新导入arr里即可
	for (int i = 0; i < len; i++)
	{
		arr[i] = brr[i];
	}
	free(brr);

}

//时间复杂度 O（nlogn）  空间复杂度（nlogn）  稳定性：稳定
void MergeSort(int* arr, int len)
{
	for (int i = 1; i < len; i *= 2)//i代表几几合并的几
	{
		Merge(arr, len, i);//O(n)
	}

}

static int Get_Figure_Max(int arr[], int len)
{
	int max = arr[0];
	for (int i = 1; i < len; i++)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}
	}

	int count = 0;
	while (max != 0)
	{
		count++;
		max /= 10;
	}
	return count;
}
//过去值n的index这个位的值是多少   123,3 ->0   123,1->2   69,0->9
int Get_Num(int n, int index)
{
	for (int i = 0; i < index; i++)
	{
		n = n / 10;
	}

	return n % 10;
}
static void Radix(int* arr, int len, int index)
{
	int brr[10][20];//申请的0~9号桶，每个桶内空间20个
	int crr[10] = { 0 };//用crr[i]里的值来代表对应的i号桶内有多少有效值

	for (int i = 0; i < len; i++)
	{
		int tmp = Get_Num(arr[i], index);//tmp保存着值arr[i]应该放的桶号
		brr[tmp][crr[tmp]++] = arr[i];
	}

	int k = 0;
	for (int i = 0; i <= 9; i++)//桶号
	{
		for (int j = 0; j < crr[i]; j++)
		{
			arr[k++] = brr[i][j];
		}
	}

}

//时间复杂度O（dn） 空间复杂度O(dn) 稳定性：稳定
void Radix_Sort(int arr[], int len)
{
	int count = Get_Figure_Max(arr, len);

	for (int i = 0; i < count; i++)
	{
		Radix(arr, len, i);//i=0以个位排序一次  i=1以十位排序一次
	}
}


//这个函数：调整一次大顶堆   时间复杂度O（log2n）
void AdjustHeap(int arr[], int start, int end)
{
	int tmp = arr[start];

	int i = start;
	int j = 2 * i + 1;

	for (j; j <= end; j = 2 * i + 1)
	{
		if (j<end && arr[j + 1]>arr[j])//如果右孩子存在，并且右孩子的值大于左孩子的值
		{
			j++;
		}

		if (arr[j] > tmp)
		{
			arr[i] = arr[j];
			i = j;
		}
		else
		{
			break;
		}
	}

	arr[i] = tmp;
}

//时间复杂度O（nlogn）   空间复杂度O（1）  稳定性：不稳定
void HeapSort(int* arr, int len)
{
	//最后一个叶子结点是len-1  所以子推父  得到最后一个非叶子节点的下标为((len-1)-1)/2
	//初始状态下，调整大顶堆需要，从最后一个非叶子节点开始，从后向前，从下向上调整
	for (int i = (len - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustHeap(arr, i, len - 1);//第三个参数，找不到规则，直接填最大下标位置即可（饱和式救援）
	}
	//当此时for循环  执行结束，   初始状态下最繁琐的调整大顶堆搞定了


	for (int i = 0; i < len - 1; i++)//轮数 
	{
		int tmp = arr[0];//交换个是根节点arr[0] 而不是arr[i]
		arr[0] = arr[len - 1 - i];
		arr[len - 1 - i] = tmp;

		AdjustHeap(arr, 0, (len - 1 - i) - 1);//  (len-1-i)-1
	}


}

int Partition(int* arr, int left, int right)
{
	int tmp = arr[left];

	while (left < right)
	{
		while (left<right && arr[right]>tmp)
			right--;
		if (left == right)
		{
			break;
		}
		arr[left] = arr[right];


		while (left < right && arr[left] <= tmp)
			left++;
		if (left == right)
		{
			break;
		}
		arr[right] = arr[left];

	}

	arr[left] = tmp;//arr[left] == arr[right]
	return left;//return right;

}
void Quick(int* arr, int left, int right)
{
	if (left < right)
	{
		int index = Partition(arr, left, right);

		if (left < index - 1)//保证基准值左边至少有两个值
		{
			Quick(arr, left, index - 1);
		}

		if (index + 1 < right)//保证基准值右边至少有两个值
		{
			Quick(arr, index + 1, right);
		}


	}
}



//快排，（综合情况来看，是最快的，数组越乱越有序）是每一次将基准值放到合适位置上   时间复杂度O（nlogn） 空间复杂度O（logn）  稳定性：不稳定
void QuickSort(int* arr, int len)
{
	Quick(arr, 0, len - 1);
}
int main()
{
	int arr[] = { 9,7,10,2,5,6,12,99,55,3,2,6,5,21 };
	//BubbleSort(arr, sizeof(arr)/sizeof(arr[0]));
	//SelectSort(arr, sizeof(arr)/sizeof(arr[0]));
	//InsertSort(arr, sizeof(arr)/sizeof(arr[0]));
	//ShellSort(arr, sizeof(arr)/sizeof(arr[0]));
	//MergeSort(arr, sizeof(arr)/sizeof(arr[0]));
	//Radix_Sort(arr, sizeof(arr)/sizeof(arr[0]));
	//HeapSort(arr, sizeof(arr)/sizeof(arr[0]));
	QuickSort(arr, sizeof(arr) / sizeof(arr[0]));
	Show(arr, sizeof(arr) / sizeof(arr[0]));
	printf("swap:%d\n", count);

	return 0;
}

在这里插入图片描述

C++——排序的稳定性
小天狼星_布莱克 的博客
06-26 1528
排序算法的稳定性
八大排序C++完整代码（冒泡、希尔、插入、选择、快排、归并、桶、堆）
12-30
本资源提供了八大经典排序算法的C++实现，包括冒泡排序、希尔排序、插入排序、选择排序、快速排序、归并排序、桶排序以及堆排序。接下来，我们将深入探讨这些排序算法的原理、效率以及它们在C++中的实现。 1. **...
算法学习 - 选择排序的稳定性讨论(C++实现)
累了就歇一会
04-03 3812
选择排序选择排序的思想很简单。 每次选择当前的最小数字。 向后移动一位，选择第二小的数字。 … 移动到倒数第二位，操作后截止。 还不懂的附上百度百科选择排序。稳定性所以到底是不是稳定的呢？不稳定解释看过上面百度百科链接的人就会觉得一定不是稳定的啊。因为例如如下： [5 8 5 2 9 4] 这个在第一次选择最小的时候，就把5和2的位置掉换了，变成如下： [2 8
论代码稳定
阿朱=行业趋势+开发管理+架构
04-24 276
阿朱出品 必属精品 阿朱原创 复制必究我经历了不同公司、不同软件研发团队，但发现犯的错误都很相似，所以总结一份，便于大家自行建设自己的团队。对于互联网公司，反正代码Own...
c++排序算法稳定性判断详解
Yoyo的博客
09-12 391
当谈到排序算法时，一个重要的概念是稳定性。排序算法的稳定性指的是当两个相等的元素在排序后保持相对位置不变。换句话说，如果有两个元素A和B，它们的值相等并且在排序之前A出现在B之前，那么在排序之后，A仍然应该出现在B之前。本文将深入探讨排序算法的稳定性，以及如何实现稳定的排序算法。在工程和科学领域中，我们经常需要对数据进行排序以便更好地分析和处理。排序算法在计算机科学中起着至关重要的作用，因此了解排序算法的性质是很有必要的。排序算法的稳定性可以理解为对于相等的元素，排序前后它们的相对位置是否被改变。
C++ 经典排序算法原理及稳定性分析
weixin_52626887的博客
09-18 1436
排序算法
c++中八大排序算法
12-31
我们这里说说八大排序就是内部排序。 当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。 快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时...
C/C++数据结构_随机10000个数：排序~8大排序代码集.rar
07-02
这里我们将详细讨论这八大排序算法以及它们的工作原理。 1. **冒泡排序（Bubble Sort）**： 冒泡排序是最基础的排序方法，通过不断交换相邻的逆序元素来逐步将最大（或最小）的元素“冒泡”到序列的末尾。其时间...
C++八大排序算法完整实现代码解析
资源摘要信息: "八大排序C++完整代码（冒泡、希尔、插入、选择、快排、归并、桶、堆）" C++是面向对象的编程语言，其在数据结构和算法方面的应用极为广泛，尤其是在排序算法的研究和实现上。排序算法是将一组数据...
各种排序算法的稳定性和时间复杂度总结
08-23
各种排序算法的稳定性和时间复杂度总结。希望大家能有所收获。
【C++】快速排序算法、代码、时空复杂度and稳定性分析
saxon_li的博客
12-11 3726
一、思想 1、基本思想：基于 交换 的高效排序算法，采用了 分治法 的思想。 2、算法描述： 从数列中取出一个数作为基准数（pivot，一般取数组第一个元素）； 把数组进行左右划分(partition)，大于基准数的元素都移至枢轴右边，小于等于基准数的元素都移至枢轴左边； 再对左右的子区间重复第二步的划分操作，直至每个子区间只有一个元素，排序完成。 3、复杂度： 复杂度 最坏时间复杂度 平均时间复杂度 最坏空间复杂度 平均空间复杂度 .
【C++】十大排序算法原理、代码、时空复杂度and稳定性分析
saxon_li的博客
12-14 1276
前言：本文排序顺序均为从小到大 一、冒泡排序 1、算法描述 ⽐较相邻的元素。如果第⼀个⽐第⼆个⼤，就交换它们两个； 对每⼀对相邻元素作同样的⼯作，从开始第⼀对到结尾的最后⼀对，这样每一趟排序，所有未排序元素中最后的元素即是最⼤的数； 重复复以上两步骤 n - 1 次（ n 为数组的大小），直到排序完成。 2、代码展示 void bubbleSort(vector<int>& num) { int n=num.size(); for(int i=0;i
2024年C C++最全【排序】七大排序特性分析及总结_各种排序的特点，2024年最新【面试必会
最新发布
2401_84973592的博客
05-13 411
排序的概念：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
【C/C++数据结构 - 2】：稳定性与优化揭秘，揭开插入排序、希尔排序和快速排序的神秘面纱！
Oh_Python的博客
10-14 567
排序算法揭秘：稳定性为何如此重要？插入排序，致力于效率优化，让你的排序更快、更准！希尔排序横空出世，超越传统，带你体验排序算法的全新进化！快速排序霸气登场，席卷而来，速度与稳定并存！排序算法的秘密尽在这里，让我们一起探寻排序的奥秘！
加强代码稳定性
「靑」'博客
09-28 593
好的代码不只是提高代码的复用率，而要建立在容易维护的基础上。 开始编码的时候不知道以后会添加什么业务，代码复用可能造成添加业务的不方便。 1 开始需要对整个系统的业务理解全面，不理解的业务请教需求人员，也不可盲目的相信。不严谨的地方和组长讨论。 2 需求变更是不能避免的，要在变化之上把握程序的稳定； 3 对同一方面的业务积累经验，预知哪里可能产生变化，使代码开始就能适应将来的需求变更； ...
C++ 数据结构与算法 （十一）（排序算法）
chenyfan_blog
04-18 1923
C++ 数据结构与算法、排序
selectsort
QS9816
05-12 844
选择排序(Selection sort) 是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一
快速排序的稳定版代码
m0_37651658的博客
03-13 828
public void quick(int[] nums,int l, int r){ if(l >= r)return; int a = l,b = r; // 拷贝数组 int[] copy = new int[r-l+1]; int start = 0,end = copy.length-1; int e = r,s = l; int privot ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值