数据结构——排序大汇总（建议收藏）

最新推荐文章于 2024-08-29 22:06:50 发布
最新推荐文章于 2024-08-29 22:06:50 发布
阅读量1.5k 收藏 40
点赞数 52
分类专栏： 且看数据结构 要好好学c语言！ 文章标签： 数据结构 排序算法 算法 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyy_3yu/article/details/140577563
版权

这篇文章将为大家详细讲解各大排序的基本思想与实现代码~

内有动图

首先，我们来看常见的排序有以下几大类：

1.插入排序

插入排序的主要思想是将每个位置的元素插入到前面已具备顺序的数组中

实际中我们玩扑克牌时，就用了插入排序的思想  

 

1.1动图展示

 

1.2代码实现

// 插入排序
void InsertSort(int* a, int n)
{
	//把end+1插入到【0，end】内
	
	for (int i = 0; i < n - 1; i++) {
		int end = i;
		int tmp = a[end + 1];
		while (end>=0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
			}
			else {
				break;
			}
			end--;
		}
		a[end + 1] = tmp;
	}
	
}

直接插入排序的特性总结：

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定  

2.希尔排序

希尔排序法又称缩小增量法。

希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个 组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工 作。当到达=1时，所有记录在统一组内排好序。

2.1动图展示

2.2代码实现

// 希尔排序
void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap!=1) {
		gap=gap/3+1;
		for (int i = 0; i < gap; i++)
		{
			for (int j = 0; j < n - gap-1; j += gap)//或者j++变为三重循环
			{
				int end = j;
				int tmp = a[end + gap];
				while (end >= 0)
				{
					if (tmp < a[end])
					{
						a[end + gap] = a[end];
					}
					else {
						break;
					}
					end-=gap;
				}
				a[end + gap] = tmp;
			}
		}
	}
	
}

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的 希尔排序的时间复杂度都不固定，因为咱们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O(n^1.25) 到 O(1.6*n^1.25)来算。

3.选择排序

直接选择排序:

  1. 在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素
  2. 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
  3. 在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

3.1动图展示

 

3.2代码实现

// 选择排序
void SelectSort(int* a, int n)
{
	int max;
	int min;

	int end = n - 1;
	int head = 0;
	while (end > head)
	{
		max = min = head;
		for (int i = head; i <= end; i++)
		{
			if (a[i] < a[min])
			{
				min = i;
			}
			if (a[i] > a[max])
			{
				max = i;
			}
		}
		if (max == head && min == end)
		{
			Swap(&a[max], &a[end]);

		}
		else if (min == end)
		{

			Swap(&a[min], &a[head]);
			Swap(&a[max], &a[end]);

		}else
		{
			Swap(&a[max], &a[end]);

			Swap(&a[min], &a[head]);
		}
		
		end--;
		head++;
	}

}

上面的方法是选择排序的改进，一趟同时找出最大和最小数 

直接选择排序的特性总结：

  1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定 

4.堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是 通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

4.1动图展示

 

4.2代码实现

// 堆排序
void AdjustDwon(int* a, int n, int root)
{
	//建大堆
	int parent = root;
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child+1<n &&a[child] < a[child + 1])//要有右孩子才能比较
		{
			child++;
		}
		if (a[parent] < a[child])
		{
			Swap(&a[parent], &a[child]);
		}
		parent = child;
		child = parent * 2 + 1;
	}
}
void HeapSort(int* a, int n)
{
	for (int i = (n - 1) / 2; i >= 0; i--)
	{
		AdjustDwon(a, n, i);
	}
	while (n--)
	{
		Swap(&a[0], &a[n]);
		AdjustDwon(a, n, 0);
	}
}

堆排序的特性总结：

  1. 堆排序使用堆来选数，效率就高了很多。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定  

5.冒泡排序

交换排序基本思想：

所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置

交换排序的特点是：

将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

5.1动图展示

 

5.2代码实现

// 冒泡排序
void BubbleSort(int* a, int n)
{
	int i, j;
	for (i = 0; i < n - 1; i++)
	{
		int t = 0;
		for (j = 0; j < n - 1 - i; j++)
		{
			if (a[j] > a[j + 1])
			{
				Swap(&a[j], &a[j + 1]);
			}
			t = 1;
		}
		if (t == 0)
		{
			break;
		}
	}
}

冒泡排序的特性总结：

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定  

6.快速排序

其基本思想为：任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。  

6.1 hoare版本

6.1.1动图展示

6.1.2代码实现

// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{

	//三数取中
	int keyi = Getmid(a, left, right);
	Swap(&a[keyi], &a[left]);
	keyi = left;



	int begin = left;
	int end = right;
	while (begin < end)
	{

		//右边找到小停
		while (begin < end && a[end] >= a[keyi])
		{
			end--;
		}

		//左边找到大停
		while (begin < end && a[begin] <= a[keyi])
		{
			begin++;
		}
		Swap(&a[begin], &a[end]);
	}
	Swap(&a[keyi], &a[begin]);
	keyi = begin;
	return keyi;
}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	//优化小区间
	if (right - left + 1 < 10)
	{
		InsertSort(a + left, right - left + 1);
		return;
	}
	int keyi = PartSort1(a,left,right);
	//int keyi = PartSort2(a, left, right);
	//int keyi = PartSort3(a, left, right);



	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

6.2 挖坑法

6.2.1动图展示

6.2.2代码实现

// 快速排序挖坑法
int PartSort2(int* a, int left, int right)
{
	//三数取中
	int keyi = Getmid(a, left, right);
	Swap(&a[keyi], &a[left]);
	keyi = left;

	int key = a[left];
	int pit = left;
	int begin = left;
	int end = right;
	while (begin < end)
	{
		while (begin < end && a[end] >= key)
		{
			end--;
		}
		a[pit] = a[end];
		pit = end;
		while (begin < end && a[begin] <= key)
		{
			begin++;
		}
		a[pit] = a[begin];
		pit = begin;

	}
	a[pit] = key;
	return pit;

}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	//优化小区间
	if (right - left + 1 < 10)
	{
		InsertSort(a + left, right - left + 1);
		return;
	}
	//int keyi = PartSort1(a,left,right);
	int keyi = PartSort2(a, left, right);
	//int keyi = PartSort3(a, left, right);



	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

6.3 前后指针法

6.3.1动图展示

6.3.2代码实现

// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{
	//三数取中
	int keyi = Getmid(a, left, right);
	Swap(&a[keyi], &a[left]);
	keyi = left;

	int prev = left;
	int cur = prev+1;
	while (cur <= right)
	{
		if (a[cur] < a[keyi]&&cur!=++prev)
		{
			Swap(&a[cur], &a[prev]);
		}
		cur++;
	}
	
	Swap(&a[prev], &a[keyi]);
	
	return prev;
}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	//优化小区间
	if (right - left + 1 < 10)
	{
		InsertSort(a + left, right - left + 1);
		return;
	}
	//int keyi = PartSort1(a,left,right);
	//int keyi = PartSort2(a, left, right);
	int keyi = PartSort3(a, left, right);



	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

6.4快速排序非递归实现 

// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
{
	Stack st;
	STInit(&st);
	STPush(&st, right);
	STPush(&st, left);
	while (!STEmpty(&st))
	{
		int begin = STTop(&st);
		STPop(&st);
		int end = STTop(&st);
		STPop(&st);
		int keyi = PartSort3(a, begin, end);

		if(end>keyi+1)
		{
			STPush(&st, end);
			STPush(&st, keyi + 1);
		}
		if(begin<keyi-1)
		{
			STPush(&st, keyi - 1);
			STPush(&st, begin);
		}
	}
	STDestroy(&st);
}

快速排序优化

  1. 三数取中法选key
  2. 递归到小的子区间时，可以考虑使用插入排序 

这两步在上述代码中都有所体现

快速排序的特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(logN)
  4. 稳定性：不稳定 

7.归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

7.1动图展示

7.2代码实现

7.2.1递归实现

void _MergeSort(int* a, int* tmp, int begin, int end)
{
	//递归停止条件
	if (begin >= end)
	{
		return;
	}
	int mid = (begin + end) / 2;
	int begin1 = begin;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = end;

	//子问题
	_MergeSort(a, tmp, begin1, end1);
	_MergeSort(a, tmp, begin2, end2);

	//当前问题
	//升序
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];

		}
		else {
			tmp[i++] = a[begin2++];

		}

	}
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}
	memcpy(a + begin, tmp + begin, sizeof(int) * (end-begin+1));
}
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	_MergeSort(a, tmp, 0, n-1);
	free(tmp);
	tmp = NULL;
}

7.2.2非递归实现

// 归并排序非递归实现
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	int gap = 1;
	while (gap < n)
	{
		int i;
		for (i = 0; i < n; i += 2 * gap)
		{
			int begin1 = i;
			int end1 = i + gap-1;
			int begin2 = i + gap;
			int end2 = i + 2 * gap-1;
			int j = i;
			// 第二组都越界不存在，这一组就不需要归并
			if (begin2 >= n)
				break;

			// 第二的组begin2没越界，end2越界了，需要修正一下，继续归并
			if (end2 >= n)
				end2 = n - 1;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else {
					tmp[j++] = a[begin2++];

				}

			}
			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2++];
			}
		}
		memcpy(a, tmp, n * sizeof(int));
		gap *= 2;
	}
	free(tmp);
	tmp = NULL;
}

归并排序的特性总结：

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定 

8.计数排序

计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 

操作步骤：

  1. 统计相同元素出现次数
  2. 根据统计的结果将序列回收到原来的序列中   

8.1动图展示

 

8.2代码实现

void CountSort(int* a, int n)
{
	int max;
	int min;
	max = min = a[0];
	for (int i = 1; i < n; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
		if (a[i] < min)
		{
			min = a[i];
		}
	}
	int range = max - min + 1;
	int* count = (int*)calloc(range, sizeof(int));
	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (count[i]--)
		{
			a[j++] = i + min;
		}
	}
	free(count);
	count = NULL;
}

计数排序的特性总结：

  1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
  2. 时间复杂度：O(MAX(N,范围))
  3. 空间复杂度：O(范围)

9.排序算法复杂度计稳定性总结 

 

 注意：这里的稳定性是指：指数组中相同元素在排序后相对位置不发生变化。

也就是原先一样大的数在排序后的相对位置不改变 

---------------------------------------------------------------------------------------------------------------------------------

本次讲解到此结束，喜欢的小伙伴们记得点赞收藏哦~ 

一条鱼头
关注
  • 52
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
专栏目录
数据结构——学习笔记——入门必看【建议收藏】
刘鑫磊
02-09 41万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
【数据结构】排序——归并排序，计数排序
m0_74091744的博客
07-11 924
1.归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。2.时间复杂度：O(N*logN)（原理在于递归方式与二叉树相似）3.空间复杂度：O(N)（开辟了一个新的动态数组空间）4.稳定性：稳定。
数据结构——重点代码汇总
qq_42587113的博客
12-15 2325
为防止溢出，队列常用循环顺序队列来实现，常用以下两种策略协助判断循环队列的空和满，即：（1）设一个数据域表示队列中的元素个数，（2）少用一个存储单元。这里采用第一种策略，分别写出入队函数int Enqueue(sql q, qtype x)和出队函数int Dequeue(sql q, qtype *x)。
【数据结构】排序算法——Lessen1
小羊的博客
07-22 3402
排序算法超超超详解
数据结构——排序（十种常用内排序算法）
qq_2210007943的博客
09-12 3144
数据结构——排序一级目录二级目录三级目录 一级目录 二级目录 三级目录
数据结构——常见简答题汇总
m0_73139998的博客
11-05 5964
本文主要介绍数据结构简答题常见题型，比如：邻接表，邻接矩阵，稀疏矩阵三元组等
数据结构八大常见的排序
m0_64146094的博客
03-28 1072
常见排序算法分类 1.插入排序 2.希尔排序(缩小增量排序) 3.选择排序 4.堆排序 5.冒泡排序 6.快速排序（递归和非递归） 7.归并排序
数据结构经典排序算法——python（详细汇总）
perfect_code_hzy的博客
08-28 1543
python算法学习笔记前言一、冒泡排序1.1 算法步骤1.2 图解1.3 排序效率1.4 Python代码实现二、选择排序2.1 算法步骤2.2 图解2.3 Python代码实现三、插入排序3.1 算法步骤3.2 图解3.3 排序效率3.4 Python代码实现四、希尔排序4.1 算法步骤4.2 图解4.3 排序效率4.4 Python代码实现五、归并排序5.1 算法步骤5.2 图解5.3 Python代码实现六、快速排序6.1 算法步骤6.2 图解6.3 Python代码实现七、堆排序7.1 算法步骤7
初识数据结构之入门必懂——八大排序
m0_64705485的博客
10-10 689
封面是帅气的霍尔大佬哟！不进来看看吗
数据结构——导图.rar
04-30
这份“数据结构——导图.rar”压缩包包含了关于数据结构的详细思维导图，一共分为7个章节，涵盖了数据结构的基础到高级主题。 1. **线性表**：线性表是最基础的数据结构之一，它是由n（n>=0）个相同类型元素构成的...
【数据结构】常见七大排序总结
四季轮换叶，一路招摇胜
10-23 6745
常见七大排序概念算法总结
数据结构之单向、双线链表
2301_78503818的博客
08-28 493
首先我们先定义链表节点的类型，以及里面包含的数据和存储下一个节点地址的指针，然后通过定义变量，使用malloc函数来申请一个头结点的空间，而后进行赋值操作即可完成对头结点的创建。链表大体可以分成有头链表（有头节点）和无头链表，今天主要记录一下单向链表和双线链表的一些基本操作。3.单向链表的遍历，寻找，删除，更改。6.链表的复杂操作（读者可酌情观看）链表空间的释放（链表的销毁）2.头插法插入链表节点。
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1226
数据结构-时间、空间复杂度-详解
【Java & 数据结构】HashMap和HashSet介绍
qq_42150700的博客
08-29 494
Map 和 Set 是 Java 集合框架中的两个接口, 其分别对应着两种不同的搜索模型. 其中 一个是纯 key 模型, 另一个则是 key-value 模型.纯 key 模型就类似于一个集合, 里面装载着一些元素, 这些元素只包含其本身. 例如我有一个冰箱, 里面装着各式各样的饮料, 那么此时这个冰箱就可以看作是一个饮料的集合, 里面装载着饮料. 此时如果我要在里面找饮料, 找的就是饮料本身.
【数据结构】-----哈希
m0_73470633的博客
08-29 454
一文看懂哈希结构！
【数据结构-二维前缀和】【含空间优化】力扣3070. 元素和小于等于 k 的子矩阵的数目
sjsjs11的博客
08-29 135
col_sum[j]在遍历行的时候，也会依次计算该列的元素和，要计算前缀和s，实际上就是目前该列的元素和逐列累加，当发现s大于k的时候，那么就停止该行接下来的前缀和，继续计算下一行第一列开始的前缀和，继续遍历行的某个位置的前缀和。这种方法就是传统的前缀和做法，在这道题中，如果group[i][j]小于k，则继续遍历，然后count增加，如果group[i][j]大于k，说明不需要继续遍历这一行接下来列的前缀和了，直接开始计算新一行每一列的前缀和。返回包含 grid 左上角元素、元素和小于或等于 k 的。
Redis八种数据结构简介
最新发布
m0_67496588的博客
08-29 581
Redis八种数据结构
数据结构-线性表
zhoupenghui168的博客
08-29 577
好了,线性表相关数据结构就基本上差不多了, 从上面可知,线性表分为顺序表,链表(单向,双向),栈,队列等,他们存储的是单值情况,那么如果要存储多值情况,如:key-value情况,怎么办呢,这里就需要使用符号表了
光电信息工程学院：数据结构实验——学生成绩管理系统实现与查询
这个学生数据结构成绩管理系统不仅锻炼了学生对数据结构（如散列和排序）的理解和应用，还培养了他们的程序设计能力和数据管理能力。通过这个实践项目，学生们能够深入理解数据结构在实际应用中的作用，并提升编程...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值