八大排序(C语言)

最新推荐文章于 2023-12-06 09:20:36 发布
最新推荐文章于 2023-12-06 09:20:36 发布
阅读量3.9w 收藏 3.1k
点赞数 691
分类专栏： 八大排序 文章标签： 经典八排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Gunanhuai/article/details/102407016
版权

八大排序

冒泡排序：

1）比较相邻的元素。如果第一个比第二个大，就交换他们两个；
2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数；
3）针对所有的元素重复以上的步骤，除了最后一个；
4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

选择排序：

1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；
2）再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾；
3）重复第二步，直到所有元素均排序完毕。

直接插入排序：

插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

算法步骤：
1）将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列；
2）从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置(相同则插入相等元素后边)。

希尔排序(递减增量排序算法)：

核心思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
1）选择一个增量序列d[1]，t[2]，…，d[k]，其中d[i]>d[j]，d[k]=1；
2）按增量序列个数k，对序列进行k 趟排序；
3）每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

堆排序：

利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

堆排序的平均时间复杂度为Ο(nlogn) 。

算法步骤：

1）创建一个堆H[0…n-1]

2）把堆首（最大值）和堆尾互换

3）把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置

4） 重复步骤2，直到堆的尺寸为1
![在这里插入图片描述](https://img-blog.csdnimg.cn/20191008203300363.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0d1bmFuaHVhaQ==,size_16,color_FFFFFF,t_7

在这里插入图片描述
在这里插入图片描述

快速排序：

分而治之。通过排序将序列分割为两部分，左边都是比基线条件小的数，右边都是比它大的数；然后再按照这个方法对分割后的两个序列排序。
在这里插入图片描述

归并排序：

1）将需要排序的序列两两划分进行第一次组内排序；

2）将第一步排好的组再次两两组合进行组内排序；

3）重复以上步骤，直至最后一次排序完成；
在这里插入图片描述

基数排序：

基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。
在这里插入图片描述

1.算法排序的时间复杂度:

时间复杂度o(n^2)
冒泡排序，选择排序，插入排序
时间复杂度o(n*logn)
归并排序，快速排序，堆排序，希尔排序
时间复杂度o(n)
基数排序

2.算法排序的空间复杂度

o(1)
冒泡排序，选择排序，插入排序，堆排序，希尔排序
o(nlogn)
快速排序
o(N)
归并排序
o(M)
基数排序

3.稳定性：相同值的元素排序前和排序后值保持不变

稳定的排序算法：冒泡排序，插入排序，归并排序，基数排序；
不稳定的排序算法：选择排序，快速排序，堆排序，希尔排序；

4.不稳定原因

选择排序原因：在选择最小值和位置为0的数交换的时候产生；
快速排序原因：在随机选择相同值中间的数的，两边的相同值的不不是被划分到选择值得左边就是选择值的右边；
堆排序原因：在每次建立大根堆后，堆顶元素会换到最后的位置上去；
希尔排序：步长为2时，第二个1跳两部，造成了不稳定；

在这里插入图片描述

5.源码

详情见代码注释

/***********************************************************

Create date:2019.10.8
Designer by:MaL
Compiling environment:Microsoft Visual Studio2012

************************************************************/

#include "sort.h"
#include <assert.h>
#include <string.h>
#include <malloc.h>
#include <stdio.h>
#include <math.h>

void Swap(int *a, int *b)
{
	int c = *a;
	*a = *b;
	*b = c;
}

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 BubbleSort(int *arr, int len)
{
	for (int i = 0; i < len - 1; ++i)
	{
		int flag = 0;
		for (int j = 0; j < len - 1 - i; ++j)
		{
			if (arr[j] > arr[j + 1])
			{
				Swap(&arr[j], &arr[j + 1]);
				flag = 1;
			}
		}

		if (flag == 0)
		{
			break;
		}
	}
}

// 选择
// O(n^2)   O(1)    不稳定
void SelectSort(int *arr, int len)
{
	for (int i = 0; i < len - 1; ++i)
	{
		int min = i;
		for (int j = i + 1; j < len; ++j)
		{
			if (arr[j] < arr[min])
			{
				min = j;
			}
		}

		Swap(&arr[i], &arr[min]);
	}
}

//直接插入排序   数据越趋于有序，其效率越高
// O(n^2)     O(1)    稳定
//  最坏 O(n^2)   最好 O(n)
void InsertSort(int *arr, int len)
{
	for (int i = 1; i < len; ++i)
	{
		int tmp = arr[i];
		int j = 0;
		for (j = i - 1; j >= 0; --j)
		{
			if (arr[j] > tmp)
			{
				arr[j + 1] = arr[j];
			}
			else
			{
				break;
			}
		}

		arr[j + 1] = tmp;
	}
}

static void Shell2(int *arr, int len, int d)
{
	for (int k = 0; k < d; ++k)
	{
		for (int i = d + k; i < len; i += d)
		{
			int tmp = arr[i];
			int j = i - d;
			for (; j >= 0; j -= d)
			{
				if (arr[j] > tmp)
				{
					arr[j + d] = arr[j];
				}
				else
				{
					break;
				}
			}

			arr[j + d] = tmp;
		}
	}
}
static void Shell(int *arr, int len, int d)
{
	for (int i = d; i < len; ++i)
	{
		int tmp = arr[i];
		int j = i - d;
		for (; j >= 0; j -= d)
		{
			if (arr[j] > tmp)
			{
				arr[j + d] = arr[j];
			}
			else
			{
				break;
			}
		}

		arr[j + d] = tmp;
	}
}

//希尔排序
//  O(n ^1.3~1.5)   O(1)    不稳定  
void ShellSort(int *arr, int len)
{
	// 目前并没有一个合适的固定分组
	//  分组的值需要两两互质，并且最后一个分组必须为1
	int d[] = { 5, 3, 1 };
	for (int i = 0; i < sizeof(d) / sizeof(d[0]); ++i)
	{
		Shell(arr, len, d[i]);
	}
}

//  O(logn)
static void OneAdjust(int *arr, int len, int root)
{
	int i = root;
	int tmp = arr[i];
	int j = 2 * i + 1; //   left
	while (j < len)
	{
		if (j + 1 < len && arr[j] < arr[j + 1])
		{
			j = j + 1; 
		}
		//  j 就是左右孩子中较大的哪一个
		if (arr[j] > tmp)
		{
			arr[i] = arr[j];
			i = j;  //  下一个子树的根
			j = 2 * i + 1; //  下一个子树的左孩子
		}
		else
		{
			break;
		}
	}

	arr[i] = tmp;
}

//  O(nlogn) 
static void CreateHeap(int *arr, int len)
{
	int root = len / 2 - 1;
	for (; root >= 0; --root)
	{
		OneAdjust(arr, len, root);  // O(logn)
	}
}

//堆排序
//  O(nlogn)     O(1)      不稳定
void HeapSort(int *arr, int len)
{
	CreateHeap(arr, len);  //  O(nlogn)

	for (int i = 0; i < len - 1; ++i)  // O(n)
	{
		Swap(&arr[0], &arr[len - 1 - i]);

		OneAdjust(arr, len - i - 1, 0);  //  O(logn)
	}
}

// O(n)
static  int  OneQuick(int *arr, int i,  int j)
{
	int tmp = arr[i];

	while (i < j)   //   保证找的整个过程  i  < j
	{
		while (i < j)   //  从后向前找比tmp小的元素  保证  i < j
		{
			if (arr[j] < tmp) break;
			j--;
		}

		arr[i] = arr[j];   //   当找到比tmp小的元素后，将j位置的值存储到i位置

		while (i < j)  //  从前向后找比tmp大的元素  保证  i < j
		{
			if (arr[i] > tmp) break;
			i++;
		}

		arr[j] = arr[i];  //   当找到比tmp大的元素后，将i位置的值存储到j位置
	}

	arr[i] = tmp;   //   i之前的数据都比tmp小， 之后的数据都比tmp大

	return i;
}

// O(nlogn)     O(logn)      不稳定
static void Quick(int *arr, int left, int right)
{
	// O(n)
	int mod = OneQuick(arr, left, right);

	if (mod - left > 1)   //  i左边剩余的数据是否超过1个
	{
		Quick(arr, left, mod - 1);
	}
	if (right - mod > 1)  // i右边剩余的数据是否超过1个
	{
		Quick(arr, mod + 1, right);
	}
}

//  
static void  ForQuick(int *arr, int left, int right)
{
	Stack st;
	int size = (int)(log10((double)(right - left + 1)) / log10((double)2));
	size = (size + 1) * sizeof(int) * 2;
	st.data = (int *)malloc(size);
	assert(st.data != NULL);
	st.top = 0;

	st.data[st.top++] = left;
	st.data[st.top++] = right;

	while (st.top != 0)
	{
		right = st.data[--st.top];
		left = st.data[--st.top];

		int mod = OneQuick(arr, left, right);

		if (mod - left > 1)
		{
			st.data[st.top++] = left;
			st.data[st.top++] = mod - 1;
		}
		if (right - mod > 1)
		{
			st.data[st.top++] = mod + 1;
			st.data[st.top++] = right;
		}
	}

	free(st.data);
}

//快速排序
void QuickSort(int *arr, int len)
{
	ForQuick(arr, 0, len - 1);
}

// O(n)
static void Meger(int *arr, int len,  int width, int *brr)
{
	int L1 = 0;
	int H1 = L1 + width - 1;
	int L2 = H1 + 1;
	int H2 = L2 + width - 1 < len - 1 ? L2 + width - 1 : len - 1;
	int num = 0;

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

		while (L1 <= H1)
		{
			brr[num++] = arr[L1++];
		}

		while (L2 <= H2)
		{
			brr[num++] = arr[L2++];
		}

		L1 = H2 + 1;
		H1 = L1 + width - 1 < len - 1 ? L1 + width - 1 : len - 1;
		L2 = H1 + 1;
		H2 = L2 + width - 1 < len - 1 ? L2 + width - 1 : len - 1;
	}

	while (L1 <= H1)
	{
		brr[num++] = arr[L1++];
	}

	for (int i = 0; i < len; ++i)
	{
		arr[i] = brr[i];
	}
}

//归并排序
// O(nlogn)    O(n)     稳定
void MegerSort(int *arr, int len)
{
	int *brr = (int *)malloc(sizeof(int)* len);

	for (int i = 1; i < len; i *= 2)
	{
		Meger(arr, len, i, brr);   // O(n)
	}

	free(brr);
}

//  求数组中最大数字的宽度
static int  GetMaxWidth(int *arr, int len)
{
	int max = arr[0];
	for (int i = 0; i < len; ++i)
	{
		if (arr[i] > max)  max = arr[i];
	}

	int width = 0;
	while (max)  //  12
	{
		width++;
		max /= 10;
	}

	return width;
}

//  求data的倒数第i+1位上的值
static int GetNumOfWidth(int data, int i)
{
	while (i)
	{
		data /= 10;
		i--;
	}

	return data % 10;
}

// O(d * n)      O(k + n)     稳定
// 基数排序      不需要比较的排序
void RadixSort(int *arr, int len)
{
	/* 
	    1、创建队列
		2、先求最大数字的位数
		3、求出相应位数的值， 并根据位数值将其存储相应的队列中
		4、按顺序输出所有队列中的值，  循环处理3,4步，循环次数由第一步算出
	*/

	Que que[10];
	for (int i = 0; i < 10; ++i)
	{
		que[i].data = (int*)malloc(sizeof(int)* len);
		assert(que[i].data != NULL);
		que[i].head = que[i].tail = 0;
	}

	int width = GetMaxWidth(arr, len); // O(n)

	for (int i = 0; i < width; ++i)  // O(d * n)
	{
		//  将数组中所有的数字取其相应位数的值，并将其存储到相应的队列中
		for (int j = 0; j < len; ++j)
		{
			int  num = GetNumOfWidth(arr[j], i);
			que[num].data[que[num].tail++] = arr[j];
		}

		int k = 0;
		for (int m = 0; m < 10; ++m)
		{
			while (que[m].head != que[m].tail)
			{
				arr[k++] = que[m].data[que[m].head++];
			}
		}

		for (int n = 0; n < 10; ++n)
		{
			que[n].head = que[n].tail = 0;
		}
	}

	for (int i = 0; i < 10; ++i)
	{
		free(que[i].data);
	}
}
_MaL
关注
  • 691
    点赞
  • 踩
  • 3188
    收藏
    觉得还不错? 一键收藏
  • 24
    评论
专栏目录
八大排序C语言实现sort.c
08-27
八大排序C语言实现
AES加密算法原理(C++实现)
m0_47533197的博客
04-04 6764
AES加密算法(c++)实现
c 语言aes算法,AES 加密算法的 C 语言实现
weixin_34990053的博客
05-23 2489
#include<stdio.h>#include"aes.h"staticu8pow_tab[256];staticu8log_tab[256];staticu8sbx_tab[256];staticu8isb_tab[256];staticu32rco_tab[10];staticu32ft_tab[4][256];staticu32it_tab[4][256];st...
C语言 AES加解密
Genven_Liang的博客
07-01 9516
AES加解密
AES加密c语言实现
qq1518572311的博客
06-14 2万+
#include &lt;stdio.h&gt; /*aes_small.c*/ //辅助矩阵 /*s盒矩阵：The AES Substitution Table*/// 256 位的密匙256 位支持长度为32 个字符 static const unsigned char sbox[256]={ //static:内部变量 const：只读，不可变常量 0x63,0x7c,0x77,0x7b...
分组密码算法AES的C/C++编程实现
m0_63002183的博客
07-10 4151
实验过程中，意识到要实现完整地AES流程是相对十分复杂的，要提前对密钥进行密钥扩展，将明文转化成十六进制变为矩阵，加密过程中，先用初始密钥进行异或，再做九轮字节代换、行移位、列混合；AES加密过程先是明文经过初始化变换，其次再经过九轮循环运算，每一次循环运算都要依次进行字节代换、行移位、列混合和轮密钥加，九轮循环运算结束后，再进行一次最终轮运算，这一轮与前面的九轮的区别除了不进行列混合，其余的不变，也即是最后一轮依次进行字节代换、行移位和轮密钥加，经过这一步骤得到的即为密文。行移位，一个比较简单的置换；
C语言的八大排序详细
01-17
八大排序的详解、代码、例题、图解，各种排序的算法比较和用法。
精通八大排序算法
11-15
对八大排序算法进行了详细的释义，包括思想过程、伪代码、实现代码。
八大排序算法C语言
04-19
总结了八大排序算法的写法，并且比较了效率，供大家学习借鉴。
C语言编程八大排序汇总
05-07
C语言编程八大排序汇总
C语言实现AES加密算法的示例代码
wzxue1984的博客
09-23 728
请注意，这只是一个简单的示例，实际的AES加密算法涉及更多复杂的操作，如密钥扩展和轮函数。为了正确实现AES加密算法，建议你参考相关的AES算法标准或参考现有的AES加密库。
AES算法描述及C语言实现
热门推荐
彼此当年少，莫负好时光
05-06 7万+
前言 AES算法是当前最流行的对称加密算法，也是一种分组加密算法，分组密码就是把明文分为固定长度的一组一组，每次加密一组数据，直到加密完整个明文数据。AES算法根据分组长度可以分为AES128, AES192，AES256，其所要求的秘钥长度和加密轮数也各不相同。鉴于这三种模式的算法在本质上没有区别，所以本文主要介绍AES-128（数据分组为16字节，秘钥长度为16字节，加密轮数为10轮），并给...
AES加密原理分部详解及c语言代码实现思路
RKAnjia的博客
04-26 3906
AESAES相关数学概念及运算群域及有限域关于有限域的运算 AES相关数学概念及运算 群 域及有限域 关于有限域的运算
C++ AES加密算法的实现（附代码）
敲不好代码的小透明的博客
03-31 2万+
AES原理讲解、代码实现
AES算法代码实现(完整C++源代码)
国科大网安二班的博客
01-23 1万+
AES加解密算法全过程实现(C++) 利用C++编程实现了AES的加解密过程。 关于列混合计算不清楚的可以看上一篇博客。 主要针对128bit的明文和密钥给出实现，其他情况需要改一下Nk,Nb,Nr的值和某些地方的数组维度。 byte GFMultiplyByte(byte L, byte R)这个函数是计算多项式模乘的结果（列混淆中的那一步）。 其他想自己动手编编的可以复制一下这里的S盒和逆S盒或者其他常量。 参考书籍是《密码编码与信息安全:C++实践》。 #include <iostream&gt
AES加密算法介绍及C语言示例
weixin_44498318的博客
10-29 1万+
需要与外界进行数据交互传输的电子产品，为保证数据安全，一般会对明文进行加密处理。总的来说就是将真正需要传输的内容转换成无法理解的数据，接收方通过预先定义的方式还原，防止第三方截取篡改。比如欧盟对数据隐私有严格的条例GDPR标准。加密算法很多，对于简单的嵌入式产品，使用对称加密算法，即加密和解密使用相同的秘钥，方便快捷。AES就属于这种，虽然存在一定风险，但对于个人消费产品已满足安全需求。 不考虑算法实现本身，本文只针对应用进行说明。 1、秘钥类型 AES加密按秘钥的长度分为128位（比特）、192位
AES实现C语言
qq_45670418的博客
07-09 2883
AES代码注释超级详细
密码学——128位AES算法（C/C++实现）
Rayme629的博客
03-30 4312
使用C/C++实现128位AES算法
c 语言常用的加密算法——AES加密算法
最新发布
A185822153的专栏
12-06 1463
在这个示例中，我们使用了AES的CBC模式进行加密。加密密钥和初始向量都是16字节长度的字符串。待加密的数据是一个字符串，我们将其长度传递给。在C语言中，可以使用openssl库来实现AES加密算法。下面是一个简单的示例代码，演示如何使用openssl库进行AES加密和解密。以上这些算法在C语言中实现时，通常会使用到openssl这样的第三方库，因为这些库已经实现了这些算法的高效实现，直接使用。数组中，其长度为原始数据的长度加上一个块的大小（16字节）。加密后，我们输出加密数据的16进制格式。
八大排序算法的时间复杂度
08-22
八大排序算法的时间复杂度如下： 1. 冒泡排序（Bubble Sort）： - 最好情况：O(n) - 平均情况：O(n^2) - 最坏情况：O(n^2) 2. 选择排序（Selection Sort）： - 最好情况：O(n^2) - 平均情况：O(n^2) - 最坏情况：O(n^2) 3. 插入排序（Insertion Sort）： - 最好情况：O(n) - 平均情况：O(n^2) - 最坏情况：O(n^2) 4. 希尔排序（Shell Sort）： - 最好情况：O(n log n) - 平均情况：取决于步长序列的选择 - 最坏情况：O(n^2) 5. 归并排序（Merge Sort）： - 最好情况：O(n log n) - 平均情况：O(n log n) - 最坏情况：O(n log n) 6. 快速排序（Quick Sort）： - 最好情况：O(n log n) - 平均情况：O(n log n) - 最坏情况：O(n^2) 7. 堆排序（Heap Sort）： - 最好情况：O(n log n) - 平均情况：O(n log n) - 最坏情况：O(n log n) 8. 计数排序（Counting Sort）： - 最好情况：O(n + k)，其中 k 是非负整数的范围 - 平均情况：O(n + k) - 最坏情况：O(n + k) 这些时间复杂度是对于算法在最好、平均和最坏情况下的性能分析。具体的时间复杂度可能还受到其他因素的影响，比如数据的初始状态、算法的实现方式等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值