【数据结构】八大排序：直接插入排序，希尔排序，直接选择排序，堆排序，冒泡排序，快速排序，归并排序，计数排序详细教学

最新推荐文章于 2025-04-07 09:40:36 发布
最新推荐文章于 2025-04-07 09:40:36 发布
阅读量2k 收藏 15
点赞数 3
文章标签： 数据结构 排序算法 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67405610/article/details/128696591
版权
本文详细讲解了八大排序算法：直接插入排序、希尔排序、直接选择排序、堆排序、冒泡排序、快速排序、归并排序和计数排序。涵盖了每种排序算法的基本思想、动图演示、代码实现、时间复杂度、空间复杂度以及稳定性分析。通过对这些排序算法的理解，读者可以根据实际情况选择合适的排序方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

一.插入排序

1.直接插入排序

动图演示
在这里插入图片描述
图片演示：

  • 每次将数据插入到有序的序列，因为第一个数可以视为有序，所以直接将第二个数插入
    在这里插入图片描述
  • 之后再将第三个数与前两个数排序
    在这里插入图片描述
  • 以此类推
    在这里插入图片描述
  • 当我们将最后一位数字插入后，整组数据就有序了
    在这里插入图片描述
  • 代码如下
//直接插入排序
void InsertSort(int* a, int n)
{
	//每次循环都会插入一个新数据
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;//end为被插入数组的最后一位的下标
		int tmp = a[end + 1];//tmp用来保存要插入的数据
		while (end >= 0)
		{
			//如果数字大于要插入的数据就要往后移一位
			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
				end--;
			}
			//如果数字小于要插入的数据就要跳出循环
			else
			{
				break;
			}
		}
		//将数据插如到end下标的后一位
		a[end + 1] = tmp;
	}
}

排序特性

1.时间复杂度 O(n2)

最好情况：当序列本身有序时，每次插入数据都是直接插入，只需遍历一次数据，时间复杂度O(n)。
最坏情况：当每次插入新数据时都要遍历一次被插入的序列，时间复杂度为O(n2)。

2.空间复杂度:O(1)

空间复杂度为常数值，所以为O(1)。

3.稳定性：稳定

遇到相同的数据直接插入到相同数据后面，不会改变相同数据的前后位置。

2.希尔排序

动图演示
在这里插入图片描述

1.希尔排序是直接插入排序的优化。
2.希尔排序分为两部分1.预排序2.直接插入排序
3.希尔排序通过预排序先将序列中的数据进行较大幅移动，让大数字往后移，小数字往前移。这样最后的直接插入排序部分就避免了当插入新数据时会出现遍历较多数据的情况

  • 先设定一个gap，gap有两层含义，第一层为每组数据的间隔，第二层为要组数的个数。
  • 当gap不为1时就是预排序，当gap为1时就是直接插入排序。
  • 预排序时对每组序列运用直接插入排序的逻辑进行排序
    假设gap=5

图片演示：
在这里插入图片描述

  • 缩小gap
    在这里插入图片描述

  • 当gap变为1时，就是直接插入排序
    在这里插入图片描述

  • 代码如下

//希尔排序
void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap /= 2;//每次缩小gap，当gap为1时就为直接插入排序
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > tmp)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

排序特性

1.时间复杂度 O(n1.3)

希尔排序的时间复杂度与gap的大小选择有关，目前还无法准确推算出希尔排序的时间复杂度，只能大概推算出为O(n1.3)。

2.空间复杂度:O(1)

空间复杂度为常数值，所以为O(1)。

3.稳定性：不稳定

在预排序阶段有可能改变相同数值的前后位置，所以不稳定

二.选择排序

1.直接选择排序

基本思想：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。
动图演示：
在这里插入图片描述
图片演示：

  • 第一次遍历数组找出最大值和最小值，将最大值和最小值和第1位和倒数第1位交换
    在这里插入图片描述
  • 第二次遍历数组，找出最大值和最小值，将最大值和最小值和第二位和倒数第二位交换，之后的以此类推
    在这里插入图片描述
  • 代码如下：
//交换函数
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//直接选择排序
void SelectSort(int* a, int n)
{
	int begin = 0;
	int end = n - 1;

	while (begin < end)
	{
		int mini = begin;
		int maxi = begin;
		for (int i = begin + 1; i <= end; i++)
		{
			if (a[mini] > a[i])
			{
				mini = i;//找出最小值的下标
			}
			if (a[maxi] < a[i])
			{
				maxi = i;//找出最大值的下标
			}
		}
		Swap(&a[begin], &a[mini]);
		//如果最大值下标在第一位，那么最小值和第一位交换完之后要将maxi赋值给最大值的下标
		if (maxi == begin)
		{
			maxi = mini;//最大值的下标和mini位置
		}
		Swap(&a[end], &a[maxi]);
		begin++;
		end--;
	}
}

排序特性

1.时间复杂度 O(n2)

直接选择排序每次都要遍历大量数据

2.空间复杂度:O(1)

空间复杂度为常数值，所以为O(1)。

3.稳定性：不稳定

如果序列两端中有和其他位置相同的值，那么交换时有可能会改变相同值的前后位置，比如
[4,5,6,4,2,8,3] 当2和4交换后，两个4的前后位置就发生了改变，所以不稳定。

2.堆排序

动图演示：
在这里插入图片描述图片来源于网络，侵删

堆排序是指利用堆这种数据结构所设计的一种排序算法，这里我们以升序为例
堆排序分为两步：1.建堆 2.利用堆进行排序

我们先来看第一步：建堆

  • 对于一个数组我们可以将其看成一个完全二叉树。
    在这里插入图片描述

  • 因为我们要排升序，所以我们需要将这颗树改为大根堆。大根堆就是每个节点的值都大于或等于其子节点的值。要将树改为大根堆可以用向下调整，并且从最后一个节点的父亲开始。
    在这里插入图片描述

我们再来看第二步：利用堆进行排序

  • 将堆顶的元素和最后一位进行交换，这样最大的数就跑到了最后一位，然后通过对堆顶向下调整保持剩下元素为大堆
    在这里插入图片描述
  • 代码如下：
//交换函数
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//向下调整函数
void AdjustDown(int* a, int n, int parent)//parent为要向下调整元素的下标
{
	int child = parent * 2 + 1;//先设定child为左孩子节点
	while (child < n)
	{
		//如果右孩子节点比左孩子节点大，则将child改为右孩子
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}

		// 如果孩子节点大于父亲节点，则和父亲交换
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		// 如果孩子节点小于父亲节点，则向下调整结束
		else
		{
			break;
		}
	}
}

//堆排序  O(N*logN)
void HeapSort(int* a, int n)
{
	//第一步：先建堆，因为排升序，所以建大根堆。O(n)
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}
	//第二步：利用堆进行排序。O(N*logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);//交换堆的首尾
		AdjustDown(a, end, 0);//堆顶向下调整
		--end;//将已经排好的元素排除在堆外
	}
}

排序特性

1.时间复杂度 O(n*logn)

第一步建堆过程的时间复杂度为O(n),第二步用堆排序过程的时间复杂度为 O(nlogn)，所以总和可以看作 O(nlogn)

2.空间复杂度:O(1)

空间复杂度为常数值，所以为O(1)。

3.稳定性：不稳定

建堆过程和堆排序过程都有可能改变相同大小元素的前后位置，所以不稳定。

三.交换排序

1.冒泡排序

动图演示：
在这里插入图片描述
基本思想：通过不断比较相邻元素，让最大的数往后移。

  • 代码如下：
//冒泡排序
void BubbleSort(int* a, int n)
{
	for (int j = 0; j < n - 1; j++)
	{
		int exchange = 0;
		for (int i = 1; i < n - j; i++)
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = 1;//这里通过一个变量,可以优化冒泡
			}
		}
		//如果exchange==0就说明序列已经全部有序，退出循环
		if (exchange == 0)
		{
			break;
		}
	}
}

2.快速排序

快速排序有三种方法：1.霍尔法，2.挖坑法，3.前后指针法
霍尔法：
动图演示：
在这里插入图片描述
基本思想：

  • 先设定第一位数为key
    在这里插入图片描述

  • 然后先右指针往左，碰到比key值小的停下，再左指针往右走，碰到比key大的值停下
    在这里插入图片描述

  • 将他们交换
    在这里插入图片描述

  • 然后先右指针继续往左，碰到比key值小的停下，再左指针往右走，碰到比key大的值停下，当他们相遇时停下
    在这里插入图片描述

  • 将相遇位置与key值交换。交换完后，key值左边的数都比key小，右边的数都比key大
    在这里插入图片描述

  • 然后对key的左区间和右区间重复上面的步骤，直到有序
    在这里插入图片描述

  • 代码如下：

//直接插入排序
void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}
//三个数中取中等大小的值
int GetMidIndex(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
	else
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[end] > a[begin])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
}
//霍尔法
int PartSort1(int* a, int begin, int end)
{
	//通过三数取中可以减少对于已经有序的序列过多的递归调用
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int left = begin;
	int right = end;
	int keyi = left;//keyi为序列第一位的下标
	while (left < right)
	{
		//右指针先走,找比a[keyi]小的数
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}

		//左指针再走,找比a[keyi]大的数
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	
	//将指针相遇位置与a[keyi]交换
	Swap(&a[keyi], &a[left]);
	keyi = left;

	return keyi;
}
//快速排序
void QuickSort(int* a, int begin, int end)
{
	//如果区间只有一个数或不存在那就不用排序，直接返回
	if (begin >= end)
	{
		return;
	}
	
	//当左右区间小于一定值时可以直接用插入排序，避免过多的递归调用
	if ((end - begin + 1) < 15)//小区间优化
	{
		//用插入排序减少递归调用
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		//对当前序列使用霍尔法，并且返回key的下标
		int keyi = PartSort1(a, begin, end);

		//[begin,keyi-1] keyi [keyi+1,end],对左右区间递归排序
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

挖坑法：
动图演示：
在这里插入图片描述
基本思想：

  1. 先将第一位保存到key，并且形成坑位
    在这里插入图片描述

  2. 然后右指针先往左走直到碰到比key值小的数停下
    在这里插入图片描述

  3. 将右指针指向的数填到坑位上，并且坑位转移到右指针所在位置
    在这里插入图片描述

  4. 左指针再往右走直到碰到比key值大的数停下
    在这里插入图片描述

  5. 将左指针指向的数填到坑位上，并且坑位转移到左指针所在位置
    在这里插入图片描述

  6. 重复2到5步骤，直到左右指针相遇时
    在这里插入图片描述

  7. 将key值填到相遇位置
    在这里插入图片描述

  8. 分别对相遇位置的左右区间重复上面步骤1到7
    在这里插入图片描述
    在这里插入图片描述

  • 代码如下：
//直接插入排序
void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}
//三个数中取中等大小的值
int GetMidIndex(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
	else
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[end] > a[begin])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
}
//挖坑法
int PartSort2(int* a, int begin, int end)
{
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int left = begin, right = end;
	int key = a[left];//将第一个数保存到key
	int hole = left;//第一个位置为坑位
	while (left < right)
	{
		//右指针先走,找小于key的值
		while (left < right && a[right] >= key)
		{
			right--;
		}

		a[hole] = a[right];//将右指针指向的值填到坑位
		hole = right;//坑位转移到右指针所在位置

		//左指针再走,找大于key的值
		while (left < right && a[left] <= key)
		{
			left++;
		}

		a[hole] = a[left];//将左指针指向的值填到坑位
		hole = left;//坑位转移到左指针所在位置
	}

	a[hole] = key;//将key值填到指针相遇的地方，指针一定在坑位相遇
	return hole;
}
//快速排序
void QuickSort(int* a, int begin, int end)
{
	//如果区间只有一个数或不存在那就不用排序，直接返回
	if (begin >= end)
	{
		return;
	}
	
	//当左右区间小于一定值时可以直接用插入排序，避免过多的递归调用
	if ((end - begin + 1) < 15)//小区间优化
	{
		//用插入排序减少递归调用
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		//对当前序列使用挖坑法，并且返回key的下标
		int keyi = PartSort2(a, begin, end);

		//[begin,keyi-1] keyi [keyi+1,end],对左右区间递归排序
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

前后指针法：
动图演示：
在这里插入图片描述
基本思想：

  1. 让key等于第一个位的下标 ，prev指向第一位，cur指向第二位
    在这里插入图片描述

  2. cur从第二位开始往后走，直到碰到比key对应值小的数
    在这里插入图片描述

  3. prev往前走一步
    在这里插入图片描述

  4. 交换prev和cur对应值
    在这里插入图片描述

  5. 重复上面2到4步骤
    在这里插入图片描述

  6. 当cur超出范围时，交换key和prev所对应值，这时prev对应值的左区间都比它小，右区间都比它大
    在这里插入图片描述

  • 代码如下：
//直接插入排序
void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}
//三个数中取中等大小的值
int GetMidIndex(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
	else
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[end] > a[begin])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
}
//前后指针法
int PartSort3(int* a, int begin, int end)
{
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int prev = begin;//prev指向第一位
	int cur = begin + 1;//cur指向第二位
	int keyi = begin;//key指向第一位
	while (cur <= end)
	{
		// 找到比key小的值时，跟++prev位置交换
		// 当++prev==cur时可以不交换
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}

	Swap(&a[keyi], &a[prev]);//交换key和prev
	keyi = prev;
	return keyi;
}
//快速排序
void QuickSort(int* a, int begin, int end)
{
	//如果区间只有一个数或不存在那就不用排序，直接返回
	if (begin >= end)
	{
		return;
	}
	
	//当左右区间小于一定值时可以直接用插入排序，避免过多的递归调用
	if ((end - begin + 1) < 15)//小区间优化
	{
		//用插入排序减少递归调用
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		//对当前序列使用挖坑法，并且返回key的下标
		int keyi = PartSort2(a, begin, end);

		//[begin,keyi-1] keyi [keyi+1,end],对左右区间递归排序
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

快速排序的非递归代码如下：
这里使用栈来模拟二叉树的前序遍历

//三个数中取中等大小的值
int GetMidIndex(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
	else
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[end] > a[begin])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
}
//霍尔法
int PartSort1(int* a, int begin, int end)
{
	//通过三数取中可以减少对于已经有序的序列过多的递归调用
	int mid = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int left = begin;
	int right = end;
	int keyi = left;//keyi为序列第一位的下标
	while (left < right)
	{
		//右指针先走,找比a[keyi]小的数
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}

		//左指针再走,找比a[keyi]大的数
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	
	//将指针相遇位置与a[keyi]交换
	Swap(&a[keyi], &a[left]);
	keyi = left;

	return keyi;
}
//快速排序的非递归
void QuickSortNonR(int* a, int begin, int end)
{
	ST st;
	StackInit(&st);
	
	//将数组首和尾下标进栈
	StackPush(&st, begin);
	StackPush(&st, end);

	//当栈不为空时继续
	while (!StackEmpty(&st))
	{
		//接收要排序的区间
		int right = StackTop(&st);
		StackPop(&st);
		int left = StackTop(&st);
		StackPop(&st);

		int keyi = PartSort1(a, left, right);//对当前序列使用霍尔排序
		// [left, keyi-1] keyi [keyi+1, right]，
		if (keyi + 1 < right)//让右区间先进栈，如果右区间只有一个数或不存在就不进栈
		{
			StackPush(&st, keyi + 1);
			StackPush(&st, right);
		}
		if (left < keyi - 1)//让左区间后进栈，如果左区间只有一个数或不存在就不进栈
		{
			StackPush(&st, left);
			StackPush(&st, keyi - 1);
		}
	}

	StackDestroy(&st);
}

排序特性

1.时间复杂度 O(n*logn)

在这里插入图片描述

2.空间复杂度:O(logn)

由于递归会消耗函数栈帧，函数栈帧最多同时存在O(logn)。

3.稳定性：不稳定

不管那种排序都有可能改变相同大小元素的前后位置，所以不稳定。

四.归并排序

动图演示：
在这里插入图片描述
基本思想：先让子序列有序，再将有序的子序列合并成有序的序列
在这里插入图片描述

  • 递归代码如下：
void _MergeSort(int* a, int begin, int end, int* tmp)
{
	//递归截止条件，如果区间只有一个数或不存在就返回
	if (begin >= end)
	{
		return;
	}
	int mid = (begin + end) / 2;
	//类似二叉树后续遍历
	// [begin, mid] [mid+1, end] 递归让子区间有序
	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid+1, end, tmp);

	// 归并[begin, mid] [mid+1, end]
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int i = begin;//额外空间下标
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] > a[begin2])
		{
			tmp[i++] = a[begin2++];
		}
		else
		{
			tmp[i++] = a[begin1++];
		}
	}
	
	//哪个序列没归并完直接全部归并
	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("mallco fail\n");
		exit(-1);
	}

	_MergeSort(a, 0, n - 1, tmp);

	free(tmp);
	tmp = NULL;
}
  • 非递归代码如下：
//归并排序非递归
void MergeSortNonR(int* a, int n)
{
	//用一个额外空间暂时存储合并数据
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("mallco fail\n");
		exit(-1);
	}

	int rangeN = 1;//归并两组中每组的数据个数
	while (rangeN<n)
	{
		for (int i = 0; i < n; i += rangeN * 2)
		{
			// [begin1,end1][begin2,end2] 归并
			int begin1 = i, end1 = i + rangeN - 1;
			int begin2 = i + rangeN, end2 = i + rangeN * 2 - 1;
			int j = i;

			// end1 begin2 end2 越界问题
			// 修正区间   归并完了整体拷贝 or 归并每组拷贝都可以
			if (end1 >= n)//end1越界，begin2和end2肯定也越界
			{
				end1 = n - 1;
				// 改为不存在区间，为了下面归并逻辑的进行，否则数组会越界访问
				begin2 = n;
				end2 = n - 1;
			}
			else if (begin2 >= n)//begin2越界，end2肯定也越界
			{
				// 改为不存在区间，为了下面归并逻辑的进行
				begin2 = n;
				end2 = n - 1;
			}
			else if (end2 >= n)//end2越界
			{
				end2 = n - 1;
			}
			
			// 归并[begin1, end1] [begin2, end2]
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] > a[begin2])
				{
					tmp[j++] = a[begin2++];
				}
				else
				{
					tmp[j++] = a[begin1++];
				}
			}
			//哪个序列没归并完直接全部归并
			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2++];
			}
		}
		
		//整体归并再拷贝
		memcpy(a, tmp, sizeof(int) * n);
		rangeN *= 2;//增加每组归并个数
	}
	
	free(tmp);
	tmp = NULL;
}

排序特性

1.时间复杂度 O(n*logn)

类似二叉树的后续遍历

2.空间复杂度:O(n)

需要额外空间暂时存储合并数据

3.稳定性：稳定

归并不会改变相同大小元素的前后位置，所以稳定。

五.计数排序

动图演示：
在这里插入图片描述图片来源网络，侵删。

基本思想：

  • 先将要排序序列的最大值和最小值找出，用max-min+1开辟出需要的计数数组count的大小。
    在这里插入图片描述

  • 遍历序列，将序列的值减去序列中的最小值之后找到对应的count数组的下标然后++。
    在这里插入图片描述
    在这里插入图片描述

  • 将count数组中大小不为0的下标加上最小值后依次填到原数组中。
    在这里插入图片描述

  • 代码如下：

//计数排序
void CountSort(int* a, int n)
{
	//找出最大和最小值
	int max = a[0];
	int min = a[0];
	for (int i = 0; i < n; i++)
	{
		if (min > a[i])
		{
			min = a[i];
		}
		if (max < a[i])
		{
			max = a[i];
		}
	}
	int range = max - min + 1;//计算要开辟的计数数组countA大小
	int* countA = (int*)calloc(range, sizeof(int));
	if (countA == NULL)
	{
		perror("calloc fail");
		exit(-1);
	}
	//遍历序列，将序列的值减去序列中的最小值之后找到对应的count数组的下标然后++。
	for (int i = 0; i < n; i++)
	{
		countA[a[i] - min]++;
	}
	//将count数组中大小不为0的下标加上最小值后依次填到原数组中。
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (countA[i]--)
		{
			a[j++] = i + min;
		}
	}
	
	free(countA);
}

排序特性

1.时间复杂度 O(n+最大值与最小值之间范围)

数据越集中，计数排序效率越高

2.空间复杂度:O(最大值与最小值之间范围)

需要开辟数组来计数

3.稳定性：稳定

计数不会改变相同大小元素的前后位置，所以稳定。

六.排序总结对比

在这里插入图片描述
通过了解不同排序的时间和空间复杂度已经稳定性，我们可以依据不同情况选择可以满足我们需求的排序

最后觉的本文好的话记得点赞加收藏哦！
在这里插入图片描述

yum更新中如何排除特定软件包？教你三种方法！
网络技术联盟站
01-25 68
在基于 Red Hat 系统的运维与管理过程中，常常会遇到需要排除特定软件包更新的场景。比如，某些关键业务应用依赖于特定版本的软件包，若随意更新可能会导致兼容性问题，影响系统的稳定运行。YUM 作为 Red Hat 系统强大的包管理工具，提供了多种方式来实现这一需求。以下将详细介绍从 YUM 更新中排除特定软件包的三种实用方法，帮助管理员更灵活地掌控系统更新策略。
Linux软件包管理（上）
Lzcsfg的博客
05-09 974
Linux 的软件包管理是指在 Linux 操作系统中安装、更新、删除和管理软件包的过程。软件包是指一个程序及其相关的元数据、配置文件和其他必要的资源。Linux 有许多不同的发行版，各自有其特定的软件包管理工具。yum updateyum remove其他发行版少见不在赘述，主要流行使用ubuntu中的apt包管理工具和centos中yum包管理工具那么本文还是针对的软件管理进行详细解读。
yum安装依赖时发现依赖冲突该如何解决
u012534547的博客
02-11 705
使用跳过冲突的依赖。使用--nobest安装可用版本。升级系统和冲突的包。清理yum缓存。查看冲突的包并手动解决依赖问题。这些方法可以帮助你解决常见的yum依赖冲突问题。
(转）yum 命令跳过特定(指定)软件包升级方法
weixin_30878361的博客
09-19 1380
适用于CentOs / RHEL /Fedora /Red Hat Enterprise 等linux版本。 Yum 的配置文件在/etc/yum/yum.conf 或者在/etc/yum.conf 。所以，需要修改配置文件。 打开/etc/yum.conf ，输入： exclude=openssl* kernel* # 这里假设是屏蔽ope...
HoRain云--yum安装软件包时如何处理依赖关系
最新发布
sinat_57153473的博客
04-07 706
🔥🔥🔥Stay Hungry Stay Foolish 道阻且长,行则将至,让我们一起加油吧！通过以上方法，可覆盖大多数依赖问题的处理场景。如果仍无法解决，请提供具体错误日志以进一步诊断。前些天发现了一个超棒的服务器购买网站，性价比超高，大内存超划算！忍不住分享一下给大家。❤️❤️❤️本人水平有限，如有纰漏，欢迎各位大佬评论批评指正！的默认行为是自动解析并安装所需依赖。
CentOS7 yum被破坏 升级python3 导致yum不能使用
轰轰烈烈的生活
08-29 1532
CentOS7 yum被破坏 升级python3 导致yum不能使用
yum软件包管理器
weixin_34256074的博客
11-28 116
Yum (Yellow dog Updater, Modified) 黄狗升级器是一个在 Fedora 中的字符前端软件包管理器。基于 RPM 包管理(介绍见RPM包及其管理)，能够从指定的服务器自动下载 RPM 包并且安装，可以处理依赖性关系，并且一次安装所有依赖的软件包，无须繁琐地一次次下载、安装。 软件包来源 可供 Yum 下载的软件包包括 Fedora 本身的软件包以及源自 rpmfu...
【Linux工具】：软件包管理器yum | 编辑器vim | 编译器gcc/g++ | 调试器gdb | 自动化构建工具make/Makefile | Linux小程序：进度条 | git命令行
DanceBit的博客
04-12 2689
我们学习 Linux 主要是在上面做开发的 —— 写代码、编译代码、调试代码、自动化构建项目、上传 github/gitee。在这里我们一共会介绍 5 - 6 个工具 —— 软件包管理器 yum、文本编译器 vim、代码编译器 gcc/g++、调试器 gdb、自动化构建项目 make/Makefile、以及 Linux 上的 git 的命令行。......
yum优化：提升软件包管理效率
Yum的原理是通过解析配置文件中的软件仓库地址，然后从指定的仓库下载RPM包，并解决依赖关系，最终完成软件包的安装、升级或删除。 Yum的工作流程主要包括以下几个步骤： - 1. 根据配置文件中的仓库地址获取软件包...
Linux下软件包管理的艺术：APT与YUM使用及问题解决（习题与答案）
本文对Linux系统下的两大主流软件包管理器APT和YUM进行了全面的介绍和比较分析。从基础概念、核心功能、高级使用技巧到问题解决，深入探讨了它们的工作原理、常用命令以及在配置优化、依赖关系处理和故障排除方面的...
yum源
03-11
- `gpgcheck=0`表示跳过数字签名验证 3. **网络yum源配置** 以阿里云源为例，创建`/etc/yum.repos.d/aliyun.repo`： ```ini [aliyun-base] name=Aliyun-CentOS-Base baseurl=...
Linux FFmpeg安装教程
热门推荐
weixin_43178406的博客
07-16 16万+
本文主要介绍了Linux FFmpeg安装教程，希望能对使用FFmpeg的同学们有所帮助。 文章目录 1. 问题描述 2. Ubuntu解决方案 3. Centos解决方案
Could not open lock file /var/lib/dpkg/lock-frontend - open (13: Permission denied) 解决方案
weixin_43178406的博客
09-02 15万+
本文主要介绍了使用apt-get install时出现Could not open lock file /var/lib/dpkg/lock-frontend - open (13: Permission denied) 解决方案，希望能对使用Linux的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
Linux查看端口对应进程的解决方案
weixin_43178406的博客
09-10 13万+
本文主要介绍了Linux查看端口对应进程的解决方案，希望能对使用Linux的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
rm: cannot remove: Device or resource busy 解决方案
weixin_43178406的博客
10-17 12万+
本文主要介绍了rm: cannot remove: Device or resource busy 解决方案，希望能对使用Linux的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
bash: git: command not found解决方案
weixin_43178406的博客
07-13 11万+
本文主要介绍了bash: git: command not found解决方案，希望能对使用git命令的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
Ubuntu出现ERROR:Unable to get file properties for ‘/usr/lib/libGL.so.1‘(No such file of directory)解决方案
weixin_43178406的博客
10-16 11万+
本文主要介绍了Ubuntu出现ERROR:Unable to get file properties for ‘/usr/lib/libGL.so.1’(No such file of directory)解决方案，希望能对使用Ubuntu的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
Linux系统解压分卷压缩文件的解决方案
weixin_43178406的博客
10-29 11万+
大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的知识进行总结与归纳，不仅形成深入且独到的理解，而且能够帮助新手快速入门。本文主要介绍了Linux系统解压分卷压缩文件的解决方案，希望能对使用Linux的同学们有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值