数据结构（十一）—七大内排序算法与优化

已于 2022-03-16 22:21:07 修改
阅读量933 收藏 3
点赞数 8
分类专栏： 数据结构 文章标签： 排序算法 数据结构 算法
于 2022-03-16 22:20:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yexiann/article/details/123514900
版权

排序真的是一个经典问题，也有很多大佬深入地研究与讲解了各种排序算法，我这里只是对我所学的几种排序进行了一下总结。深入地讲解可以看其他大佬的ヾ(◍°∇°◍)ﾉﾞ
放大佬的博客地址在此

大佬博客地址

文章目录

一、排序的概念与分类

在这里插入图片描述
排序中的术语：
稳定性： 意思就是，如果本来A小于B，在原始序列中就是A的位置就是在B前面，但是经过排序算法以后，可能出现B在A前面的情况，这时就称这个排序算法是不稳定的。
时间复杂度： 这个在数据结构（一）里已经写过了，说白了就是用来衡量一个算法执行起来哪个效率更快。

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

本篇博客主要介绍的是内排序的七大算法。

二、内排序的性能影响因素

  1. 时间性能：
    在内排序中，主要进行的两种操作，比较和移动。比较指关键字之间的比较，这是要做排序的最起码的操作。移动是指记录从一个位置移动到另一个位置。高效率的内排序算法应该具有尽可能少的关键字比较次数和记录的移动次数。
  2. 辅助空间：
    是指除了存放待排序所占用的存储空间之外，执行算法所需要的其他存储空间。
  3. 算法的复杂性：
    通俗的理解就是这个算法学起来难不难理解。

三、冒泡排序及其优化

3.1冒泡排序算法的实现

冒泡排序是一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为之。
在这里插入图片描述
代码实现：
先放一个交换函数

/* 交换L中数组r的下标为i和j的值 */
void swap(SqList *L,int i,int j) 
{ 
	int temp=L->r[i]; 
	L->r[i]=L->r[j]; 
	L->r[j]=temp; 
}

冒泡排序的实现

/* 对顺序表L作冒泡排序 */
void BubbleSort(SqList *L)
{ 
	int i,j;
	for(i=1;i<L->length;i++)
	{
		for(j=L->length-1;j>=i;j--) /* 注意j是从后往前循环 */
		{
			if(L->r[j]>L->r[j+1]) 	/* 若前者大于后者（注意这里与上一算法的差异）*/
			{
				 swap(L,j,j+1);		/* 交换L->r[j]与L->r[j+1]的值 */
			}
		}
	}
}

3.2冒泡排序的优化

上面的代码有可避免的不必要的操作吗？答案是有的，如果在某次交换以后，后面的序列已经处于有序的状态，但上面的算法依旧比较了后面的每一个数，这种比较是没有必要的，可以规避的。
加一个判断，后面的序列是否还有交换的，如果没有，则退出循环。

/* 对顺序表L作改进冒泡算法 */
void BubbleSort2(SqList *L)
{ 
	int i,j;
	Status flag=TRUE;					/* flag用来作为标记 */
	for(i=1;i<L->length && flag;i++) 	/* 若flag为true有数据交换，否则退出循环 */
	{
		flag=FALSE;						/* 初始为False */
		for(j=L->length-1;j>=i;j--)
		{
			if(L->r[j]>L->r[j+1])
			{
				swap(L,j,j+1);			/* 交换L->r[j]与L->r[j+1]的值 */
				flag=TRUE;				/* 如果有数据交换，则flag为true */
			}
		}
	}
}

3.3冒泡排序的复杂度分析(优化后)

最好的情况：比较次数n-1，时间复杂度O（n）
最差的情况：比较次数n(n-1)/2，时间复杂度O（n2）
总的时间复杂的：O(n2)

四、简单选择排序

4.1简单选择排序算法的实现

简单选择排序就是通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i(1<=i<=n)个记录交换。
简单的说就是每一次循环，找出剩下元素中最小的那一个，和未排序中的第一个交换。

在这里插入图片描述

/* 对顺序表L作简单选择排序 */
void SelectSort(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);				/* 交换L->r[i]与L->r[min]的值 */
	}
}

4.2简单选择排序的复杂度分析

最好的情况：比较次数n(n-1)/2，交换次数0
最差的情况：比较次数n(n-1)/2，交换次数n-1
总时间复杂度：O（n2）

五、直接插入排序

5.1直接插入排序算法的实现

直接插入排序的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录增1的有序表。
在这里插入图片描述

void InsertSort(SqList *L) 			/* 对顺序表L作直接插入排序 */
{ 
	int i,j;
	for(i=2;i<=L->length;i++)
	{
		if (L->r[i]<L->r[i-1]) 		/* 需将L->r[i]插入有序子表 */
		{
			L->r[0]=L->r[i]; 		/* 设置哨兵 */
			for(j=i-1;L->r[j]>L->r[0];j--)
				L->r[j+1]=L->r[j]; 	/* 记录后移 */
			L->r[j+1]=L->r[0]; 		/* 插入到正确位置 */
		}
	}
}

5.2直接插入排序的复杂度分析

空间上：一个辅助空间
最好的情况：O（n）
最坏的情况：O（n2）
平均比较和移动：n2/4
总时间复杂度：O（n2）

六、希尔排序

6.1希尔排序的算法实现

希尔排序是直接插入排序的优化，我们先把序列变得基本有序，在进行插入排序，就能插入操作减少。
在这里插入图片描述

void ShellSort(SqList *L) 					/* 对顺序表L作希尔排序 */
{
	int i,j,k=0;
	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]<L->r[j];j-=increment)
					L->r[j+increment]=L->r[j]; /*  记录后移，查找插入位置 */
				L->r[j+increment]=L->r[0]; 	/*  插入 */
			}
		}
	}
	while(increment>1);
}

6.2希尔排序的复杂度分析

由于增量的选取问题仍然是一个难题，但经过大量实验研究，可以确定最佳增量序列。大量研究表明此时的时间复杂度为
O（n3/2）要优于前面所讲的算法，但是由于增量序列的选取等问题，以及希尔排序的不稳定性，使用希尔排序的地方并不多，但它突破了排序算法必须O（n2）的界限。

七、堆排序

7.1堆排序的算法实现

将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次最大值。如此往复，便能得到一个序列了。
难点：
将无序序列构建成一个堆
如何在输出堆顶元素后，调整剩余元素成为一个新的堆

在这里插入图片描述

void HeapSort(SqList *L)		/* 对顺序表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]重新调整为大顶堆 */
	}
}

void HeapAdjust(SqList *L,int s,int m)
{ /* 本函数调整L->r[s]的关键字，使L->r[s..m]成为一个大顶堆 */
	int temp,j;
	temp=L->r[s];
	for(j=2*s;j<=m;j*=2) 	/* 沿关键字较大的孩子结点向下筛选 */
	{
		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; 			/* 插入 */
}

7.2堆排序的复杂度分析

构建堆：O（n）
重建堆：O（nlogn）
总的时间复杂度：O（nlongn）
可以看出这个算法的复杂度是很高的，但是对于堆排序而言，要理解起来还是非常困难的。

八、归并排序

8.1归并排序的算法实现

假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到【n/2】（【】表示不小于这个数的最小整数）个长度为2或1的有序子序列；再两两归并，如此重复，直至得到一个长度为n的有序序列为之。
在这里插入图片描述

/* 对顺序表L作归并排序 */
void MergeSort(SqList *L)
{ 
 	MSort(L->r,L->r,1,L->length);
}

/* 将SR[s..t]归并排序为TR1[s..t] */
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]和TR2[m+1..t]归并到TR1[s..t] */
	}
}


void Merge(int SR[],int TR[],int i,int m,int n)
{ /* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..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++];
		else
			TR[k]=SR[j++];
	}
	if(i<=m)
	{
		for(l=0;l<=m-i;l++)
			TR[k+l]=SR[i+l];		/* 将剩余的SR[i..m]复制到TR */
	}
	if(j<=n)
	{
		for(l=0;l<=n-j;l++)
			TR[k+l]=SR[j+l];		/* 将剩余的SR[j..n]复制到TR */
	}
}

8.2归并排序的优化（非递归实现归并排序）

void MergeSort2(SqList *L) 				 /* 对顺序表L作归并非递归排序 */
{
	int* TR=(int*)malloc(L->length * sizeof(int));	/* 申请额外空间 */
    int k=1;
	while(k<L->length)
	{
		MergePass(L->r,TR,k,L->length);
		k=2*k;										/* 子序列长度加倍 */
		MergePass(TR,L->r,k,L->length);
		k=2*k;										/* 子序列长度加倍 */       
	}
}


void MergePass(int SR[],int TR[],int s,int n)
{/* 将SR[]中相邻长度为s的子序列两两归并到TR[] */
	int i=1;
	int j;
	while(i <= n-2*s+1)					/* 两两归并 */
	{
		Merge(SR,TR,i,i+s-1,i+2*s-1);
		i=i+2*s;        
	}
	if(i<n-s+1) 						/* 归并最后两个序列 */
		Merge(SR,TR,i,i+s-1,n);
	else 								/* 若最后只剩下单个子序列 */
		for(j =i;j <= n;j++)
			TR[j] = SR[j];
}

8.3归并排序的复杂度分析

最好的情况：O（nlogn）
最坏的情况：O（nlogn）
平均的情况：O（nlogn）
最终的时间复杂度：O（nlogn）
空间复杂度：O（n+logn）

九、快速排序

9.1快速排序的算法实现

通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。
在这里插入图片描述

/* 对顺序表L作快速排序 */
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)
	{
		/* 将L->r[low..high]一分为二，算出枢轴值pivot */
		pivot=Partition(L,low,high); 
		QSort(L,low,pivot-1);		 /*  对低子表递归排序 */
		QSort(L,pivot+1,high);		 /*  对高子表递归排序 */
	}
}

int Partition(SqList *L,int low,int high)
{/* 交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置，此时在它之前(后)均不大(小)于它。*/
	int pivotkey;

	pivotkey=L->r[low]; 	/* 用子表的第一个记录作枢轴记录 */
	while(low<high) 		/* 从表的两端交替地向中间扫描 */
	{ 
		 while(low<high&&L->r[high]>=pivotkey)
			high--;
		 swap(L,low,high);	/* 将比枢轴记录小的记录交换到低端 */
		 while(low<high&&L->r[low]<=pivotkey)
			low++;
		 swap(L,low,high);	/* 将比枢轴记录大的记录交换到高端 */
	}
	return low; 			/* 返回枢轴所在位置 */
}

9.2快速排序算法的优化

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.优化不必要的交换，我们可以将枢轴备份在0的位置，避免枢轴不必要的移动。

/* 快速排序优化算法 */
int Partition1(SqList *L,int low,int high)
{ 
	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);				/* 交换中间与左端数据，保证左端较小 */
	
	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; 					/* 返回枢轴所在位置 */
}

3.判断是否需要使用快排，对于数组而言，如果数组本身数量不多，是没有必要使用快速排序的。因为大量的递归操作在小数组中，反而是不利的。
加入判断，大于50的时候再使用快排

#define MAX_LENGTH_INSERT_SORT 7 /* 用于快速排序时判断是否选用插入排序阙值 */
/* 对顺序表L中的子序列L.r[low..high]作快速排序 */
void QSort1(SqList *L,int low,int high)
{ 
	int pivot;
	if((high-low)>MAX_LENGTH_INSERT_SORT)
	{
		pivot=Partition1(L,low,high); 	/* 将L->r[low..high]一分为二，算出枢轴值pivot */
		QSort1(L,low,pivot-1);			/* 对低子表递归排序 */
		QSort1(L,pivot+1,high);			/* 对高子表递归排序 */
	}
	else
		InsertSort(L);					/* 当high-low小于等于常数时用直接插入排序 */
}

4.优化递归操作，使用尾递归

/* 尾递归 */
void QSort2(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 */
			QSort2(L,low,pivot-1);		/* 对低子表递归排序 */
			low=pivot+1;				/* 尾递归 */
		}
	}
	else
		InsertSort(L);					/* 当high-low小于等于常数时用直接插入排序 */
}

9.3快速排序的复杂度分析

最优时间复杂度：O（nlogn）
最坏时间复杂度：O（n2）
平均时间复杂度：O（nlogn）
最坏空间复杂度：O（logn）
最好空间复杂度：O（n）
平均空间复杂度：O（logn）

十、几种排序的比较

在这里插入图片描述

独奏夜上弦^O^
关注
专栏目录
【数据结构】常见七大排序总结
四季轮换叶，一路招摇胜
10-23 6780
常见七大排序概念算法总结
内部排序算法总结
点滴
03-22 1221
内部排序算法总结 排序算法介绍 排序算法主要可以分为内部排序和外部排序，其中内部排序由可以分为非线性时间比较排序和线性时间非比较排序，前者主要通过比较来决定元素之间的相对次序，都有关键字的比较和记录的移动，其时间复杂度不能突破O(nlogn),后者不需要通过比较来进行,可以以线性时间运行。 排序算法分类 非线性时间比较排序： 插入排序：简单插入排序、折半插入排序、希尔...
内部排序算法
dl156001的博客
12-25 139
typedef struct{ int key; int Info; }RedType; typedef struct{ RedType* r; int length; }Sqlist; void InsertSort(Sqlist &L); void BinInsertSort(Sqlist &L); v...
内排序算法的整理（一）
dayi2900的博客
08-22 132
对各种内排序算法进行了整理，不足的日后补充。 1.冒泡排序 冒泡排序属于交换排序，其基本思想是通过无序区中相邻元素关键字间的比较和位置的交换使关键字最小的元素如气泡一般逐渐往上“漂浮”至“水面”，该算法时间复杂度为O(n^2)。 伪代码如下： void BubbleSort(RecType R[],int n) { int i,j; for(i=...
内排序算法
bestrivern的博客
01-03 262
一.综合比较 稳定性：重复元素之间的相对次序在排序前后保持一致 排序算法 时间复杂度 稳定性 冒泡排序(bubblesort) O(N^2) 稳定 归并排序(mergesort) O(NlogN) 稳定 选择排序(selectsort) O(N^2)   快速排序(quicksort)     堆排序()  ...
【数据结构】七大排序算法（超详细）
m0_59176913的博客
06-10 3673
本文详细介绍了数据结构中的七大排序算法
完整精品课件 吉林大学数据结构与算法课程 由浅入深 讲解清晰 07 第七章 排序（共151页）.ppt
10-06
数据结构与算法是计算机科学的基础，排序...总结起来，吉林大学的数据结构与算法课程全面涵盖了排序算法的基础知识和高级主题，旨在培养学生的算法思维和解决问题的能力，为他们在计算机科学领域的发展打下坚实的基础。
数据结构程序设计-各种排序算法时间性能的比较.doc
05-26
### 数据结构程序设计——各种排序算法时间性能的比较 #### 设计目的 本课程设计的主要目的是让学生更加深入地了解各种不同的排序算法，并掌握其在不同数据情况下的性能表现。通过对比分析，帮助学生理解每种排序...
七大经典排序算法总结详解
最新发布
12-29
以上七大排序算法各有特点，选择哪种取决于具体的应用场景。例如，如果数据基本有序，插入排序可能更合适；对于大规模数据，快速排序或归并排序是更好的选择。理解这些排序算法，不仅有助于编程实践，也有助于提升...
内排序算法一览
夜飘凌的博客
07-30 599
#include<stdio.h> #include<stdlib.h> #include<string.h> #include<time.h> #include<Windows.h> typedef int keytype; typedef struct { keytype key;/*关键字码*/ }RecType; int s[50][2];/*辅助栈s*/ void PrintArray(RecType R[],int n) {
python内排序算法（冒泡 插入 选择 堆 归并 快排）
遇到问题写下来，为了以后方便查啊～
04-19 780
python 内排序算法
各种内部排序算法!
liyanguestc的专栏
09-22 931
各种内部排序算法!! //排序算法//sunboy 2007.9.19#include iostream>using namespace std;#define LEN 8void Print(int a[])...{      int i;    for(i=0;iLEN;i++)        couta[i]" ";    coutendl;}void swap(int &a,i
算法总结：内排序
weixin_49196365的博客
07-17 589
算法总结：排序归并排序 归并排序 void process(vector<int> &arr, int l, int r, vector<int> &temp) { if (r - l <= 1) return; int mid = l + (r - l) / 2; process(arr, l, mid, temp); process(arr, mid, r, temp); int i = l, j = mid, k
十大排序算法（内排序）
飞奔的WSL-WLL
03-28 584
冒泡排序 思路：第一项和第二项如果不满足既定顺序则交换。第二项和第三项如果不满足既定顺序则交换，满足既定顺序不交换，以此类推，可以发现一次排序下来 ...
图解"数据结构--内部排序算法"----选择排序：直接选择排序、堆排序
马兆娟 廊坊师范学院信息技术提高班第八期
10-30 4248
一、选择排序(Selection Sort)的基本思想      每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子文件的最后，直到全部记录排序完毕。 二、选择排序分类      本文介绍两种选择排序：直接选择排序、堆排序。 2.1 直接选择排序         2.1.1 直接选择排序的基本思想    　     n个记录的文件的直接选择
内排序算法之 —— 归并排序
黄飞的博客专栏
02-24 406
归并排序的基本思想是：首先，将 R[0..n-1] 看成是 n 个长度为1的有序表，将相邻的有序表成对归并，得到n/2个长度为2的有序表；然后，再将这些有序表成对归并，得到n/4个长度为4的有序表，如此反复进行下去，最后得到一个长度为n的有序表。这里引用另一位博主的解析图： C++代码示例：void Merge(vector<int> R, int low, int mid, int high)
数据结构精讲：七大排序算法详解与度量
本资源是一份关于数据结构课程的详细讲义，着重于第七章——排序。章节内容深入浅出地介绍了排序的基本概念和各种排序算法，包括插入排序、交换排序（如冒泡排序和快速排序）、选择排序、合并排序、基于关键词比较的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值