C / C++ 数据结构与算法（排序）-优快云博客

本文链接：https://blog.youkuaiyun.com/Jinxiaoyu886/article/details/95054782

本文深入讲解了各种排序算法，包括简单选择排序、直接插入排序、希尔排序、堆排序、归并排序、快速排序等，详细介绍了每种算法的实现原理、代码实现及优化策略。

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

排序：假设含有n个记录的序列为{r1,r2,…rn}，其相应的关键字分别为{k1.k2…kn}，需确定1,2,…,n的一种排序p1,p2,…pn，使其相应的关键字满足kp1<=kp2<=，，，<=kpn（非递减或递增）关系，即使得序列称为一个按关键字有序的序列{rp1,rp2…rpn},这样的操作称为排序

排序的稳定性

假设ki=kj(1<=i<=n,1<=j<=n,i≠j），且排序前的序列中ri领先于rj（即i<j）。如果排序后ri仍然领先于rj，则称所用的排序方法是稳定的；反之，若可能使得排序后的序列中rj领先于ri，则称所用的排序是不稳定的。

内排序和外排序

内排序是在排序整个过程中，待排序的所有记录全部被放置在内存中。外排序是由于排序的记录个数太多，不能同时放置在内存，整个排序过程需要在内外存之间多次交换数据才能进行

对于内排序来说，受到3个方面的影响

时间性能
辅助空间
算法的复杂性

内排序分为：

插入排序
交换排序
选择排序
归并排序

简单选择排序

简单选择排序算法

通过n-i次关键字间的比较，从n-i-1个记录中选出关键字最小的记录，并和第i(1<=i<=n)个记录交换之。
代码：

void SelctSort(SqList *L)
{
	int i, j,min;
	for (i=1;i<L->length; i++)
	{
		min = i; //当前下标定义为最小值下标
		for (j = i+1; j<=L->length; j++)
		{ 
			if(L->r[min]>L->r[j]) //如果有小于当前最小值的关键字
				min = j; //将此关键字的下标赋值给min
		}
		if (i!=min) //若min不等于i，说明找到了最小值，交换
			swap (L,i,min) 
}

简单选择排序的性能要优于冒泡

直接插入排序

直接插入排序的基本操作时将一个记录插入到已经排好序的有序表中，得到一个新的，记录数加1的有序表。

代码：

void InsertSort(SqList *L)
{
	int i,j;
	for (i=2;i<=L->length;i++) // 默认i=1 时候的数据已经是排好位置的
	{
		if (L->r[i]<L->r[i-1]) //需将L->r[i]插入有序子表
		{
			L->r[0]=L->r[i]; //设置哨兵
			for (j = i-1； L->r[j+1]<L->r[0]; j--)
				{
					L->r[j+1] = L->r[j]; //记录后移
				}
			L->r[j+1] = L->r[0]; // 移动到正确位置
		}
	}
}

直接插入排序法比冒泡法和简单选择排序的性能要好一些。

希尔排序

跳跃分割：将**相距某个“增量”**的记录组成一个子序列，这样才能保证在子序列内分别进行直接插入排序后得到的结果是基本有序而不是局部有序。

代码：

void ShellSort (SqList *L)
{
	int i,j;
	int increment = L->length;
	do
	{
		increment = increment / 3+1; //增量序列
		for ( i=increment+1; i<=L->length; i++)
			{
				if (L->r[i]<L->r[i-increment])
					{ //需将L->r[i]插入有序增量子表
						L->r[0] = L->r[i]; //暂存在L->r[0]
						for (j = i-increment; j>0&&L->r[0]<r[j]; j -=increment;)
							{L->r[j+increment]=L->r[j]} //记录后移
						L->r[j+increment] = L->r[0]; //插入
					}
				}
			}
		while(increment>1);
}

时间复杂度为O（n^3/2）,优于前面的O（n²）

堆排序

堆是具有下列性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆，或者每个结点的值都小于等于其左右孩子结点的值，称为小顶堆

堆排序算法

堆排序：利用堆（假设是大顶堆）进行排序的方法。它的基本思想是，将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根节点。将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次小值。如此反复执行，就能得到一个有序序列了。

代码：

void HeapSort(SqList *L)
{
	int i;
	for (i=L->length/2;i>0;i--) //把L中的r构建成一个大顶堆
		HeapAdjust(L,i,L->length);
	
	for (i=L->length;i>1;i--)
	{
		swap(L,1,i); // 将堆顶记录和当前为经排序子序列的最后一个记录交换
		HeapAdjust(L,1,i-1); //将L->r[1...i-1]重新调整为大顶堆
	}
}
// 已知L->r[s...m]中记录的关键字除L->r[s]之外均满足堆的定义
//本函数调整L->r[s]的关键字，使L->r[s...m]称为一个大顶堆
void HeapAdjust(SqList *L, int s, int m)
{
	int temp,j;
	temp=L->r[s];
	for (j=2*s;j<=m;j*=2) //沿关键字较大的孩子结点向下筛选，
	//当前结点序号s，其左孩子序号是2s，右孩子是2s+1；
	{
		if (j<m && L->r[j]<L->r[j+1]) 
			++j;   //j为关键字中较大的记录的下标
		if (temp>=L->r[j]
			break; //rc应该插在位置s上
		L->r[s]=L->r[j];
		s=j;
	}
	L->r[s]=temp; //插入
}

归并排序

归并排序算法

归并排序，就是利用归并的思想实现的排序方法。它的原理是假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到[n/2]
([x]表示不小于x的最小整数）个长度为2或1的有序子序列；再两两归并,。。。。,如此重复，直到得到一个长度为n的有序序列为止。

代码：

void MergeSort (SqList *L)
{
	MSort (L->r,L->r, 1, L->length)；
}

void MSort (int SR[],int TR1[],int s, int t)
{
	int m;
	int TR2[MAXSIZE+1];
	if (s=t)
		TR1[s]=SR[s];
	else
	{
		m=(s+t)/2; //将SR[s...t]平分为SR[s...m]和SR[m+1...t]
		MSort(SR,TR2,s,m);//递归将SR[s...m]归并为有序的TR2[s..m]
		MSort(SR,TR2,m+1,t);//递归将SR[m+1...t]归并为有序的TR2[m+1...t]
		Merge(TR2,TR1,s,m,t);//递归将TR2[s...m]和TR1[m+1..t]归并为有序的TR1[s..t]
	}
}

void Merge (int SR[],int TR[],int i,int m,int n)
{
	int j, k, l;
	for (j=m+1, k=i; i<=m&&j<=n;k++)// 将SR中记录由小到达归并入TR
	{
		if (SR[i]<SR[j])
			TR[k]=SR[i++];//先是TR[k]=SR[i]再i++
		else
			TR[k]=SR[j++];
	}
	if (i<=m)
	{
		for (l=0;l<=m;i++)
			TR[k+1]=SR[i+l]; //将剩余的SR[i..m]复制到TR
	}
	if(j<=n)
	{
	for (l=0;l<=n-j;l++)
		TR[k+1]=SR[j+l]  //将剩余的SR[j...n]复制到TR
	}
}

快速排序

20世纪十大算法之一

快速排序算法

快速排序的基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可以分别对这两部分记录继续排序，以达到整个序列有序的目的。
代码：

void QuickSort(SqList *L)
{
	QSort (L,1,L->length);
}
//对顺序表L中的子序列L->r[low..high]作快速排序
void QSort (SqList *L,int low, int high)
{
	int pivot;
	if (low<high)
	{
		pivot = Partition(L,low,high);//将L->r[low..high]一分为二,算出枢轴值
		QSort(L, low, pivot-1); //对低子表递归排序
		QSort(L, pivot+1,high);//对高子表递归排序
	}
}
//交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置
//此时在它之前（后）的记录均不大（小）于它
int Partition(SqList *L, int low, int high)
{
	int pivotkey;
	pivotkey=L->r[low]; //用子表的第一个记录作枢轴记录
	while(low<high) //从表的两端交替向中间扫描
	{
		while(low<high&&L->[high]>=pivotkey)
			high--;
		swap(L,low,high); //将比枢轴记录小的记录交换到低端
		while (low<high&&L->r[low]<=pivotkey)
			low++;
		swap(L,low,high); //将比枢轴记录大的记录交换到低端
	}
	return low; //返回枢轴所在的位置

优化快速排序

1、优化选取枢轴

不能固定地选取第一个数作为枢轴

方法：三数取中
取三个关键字先进行排序，将中间数作为枢轴，一般是取左端、中间和右端三个数,这样枢轴一定不会是最小值或最大值
在上面添加代码：

int pivotkey;
int m = low + (high - low) /2; //计算数组中间元素的下标
if (L->r[low]>L->r[high])
	swap(L,low,high); //交换左端与右端数据，保证左端比较小
if (L->r[m]>L->r[high])
	swap(L,high,m); // 交换中间与右端数据，保证中间较小
if (L->r[m]>L->r[low])
	swap(L,m,low); //交换中间与左端数据，保证中间较小
//此时L,r[low]已经成为整个序列左中右三个关键字的中间值

pivotkey = L->r[low]; //用子表的第一个记录

2、优化不必要的交换

int Partition (SqList *L, int low, int high)
{
	int pivotkey;
	//省略三数取中的代码 
	pivotkey = L->r[low];//子表的第一个记录作枢轴记录
	L->r[0] = pivotkey; // 将枢轴关键字备份到L->r[0]
	while  (low<high)  // 从表的两端交替向中间扫描
	{
		while (low<high&&L->r[high]>=pivotkey)
			high--;
		L->r[low]=L->r[high];//采用交替而不是交换的方式操作
		while (low<high&&L->r[low]<=pivotkey)
			low++;
		L->r[high]=L->r[low]
	}
	L->r[low]=L=>r[0]; //将枢轴数值替换回L->r[low]
	return low;
}

优化小数组时的排序方案

改进QSort函数

void QSort (SqList &L, int low, int high)
{
	int pivot;
	if ((high-low)>MAX_LENGTH_INSERT_SORT)
	{
		//当high-low大于常熟时用快速排序
		pivot=Partition(L, low, high) //将L.r[low..high]一分为二，并算出枢轴值
		QSort(L,low,pivot-1); //对低子表递归排序
		QSort(L,pivot+1,high);//对高子表递归排序
	}
	else //当high-low小于常数时用直接插入排序
		InsrtSort(L);
}

优化递归操作

减少递归
代码：

void QSort1(SqList *L, int low, int high)
{
	int pivot;
	if((high-low)>MAX_LENGTH_INSERT_SORT)
	{
		while (low<high)
		{
			pivot= Partition1(L,low,high); // L.r[low..high]一分为二，算出枢轴值pivot
			QSort1(L,low,pivot-1); //对低子表递归排序
			low = pivot + 1; //尾递归
		}
	}
	else
	 InsertSort(L);
}