考研数据结构————第八章：排序

最新推荐文章于 2024-06-06 09:35:49 发布

学号Java

最新推荐文章于 2024-06-06 09:35:49 发布

阅读量296

点赞数 2

分类专栏：考研数据结构

本文链接：https://blog.csdn.net/qq_42147171/article/details/109234052

版权

考研数据结构专栏收录该内容

4 篇文章 4 订阅

订阅专栏

文章目录

排序算法

排序算法

主要讲四种排序算法，包括插入排序、交换排序、选择排序、归并排序和基数排序。然后对这些算法进行一些比较。算法的思想我主要以画图的形式展现。

1.插入排序

1.1直接插入排序

思路：

用当前的元素依次向前进行比较，由于前面的元素都排好序了，比较就直接从后往前比，与之比较的元素比当前元素大则右移，若比当前元素小，则当前元素插入到该元素的后面。

代码：

#include <stdio.h>
void InsertSort(int A[],int n){
	int i,j;
	for(i=2;i<n;i++){//从第二个开始遍历，第一个默认排序好了因为只有一个元素
		A[0]=A[i];	//这里A[0]用来存储当前比较的元素，就是书上说的什么哨兵
		printf("打印j的值："); //测试的时候写的，没啥用
		for(j=i-1;A[0]<A[j];j--){//从当前元素的前一个开始向前比较，一直比较到某个元素小于等于当前元素。
			printf("%d  ",j);
			A[j+1]=A[j];//将元素后移(为什么后移？很明显啊，因为这个元素比当前元素大)
		}
			printf("\n");
			A[j+1]=A[0];//将当前元素放到对应的地方(为什么是j+1啊，而不是j，因为A[j]<=A[0],A[0]要放到他的后面，肯定是j+1)
	}
	printf("排序结果为："); //输出结果
	for(i=1;i<n;i++){
		printf("%d   ",A[i]); 
	}
}

int main(){
	int A[]={0,5,4,6,2,4,7,8,5,1,9,10};
	InsertSort(A,sizeof(A)/sizeof(A[0]));//sizeof(A)/sizeof(A[0])计算数组长度
	return 0; 
}

1.2折半插入排序

思路：

大概思路和上面的直接插入排序一样,但是对于当前元素的插入位置的查找用了折半查找的思想，因为前面的元素是有序的所以，大家懂得，可以折半查找。就可以减少平均的时间复杂度（并不是说一定就比直接插入快，但是在元素很多的情况下，平均下来时间复杂度会减少，因为折半查找嘛，时间复杂度就是log₂n）

代码：

# include<stdio.h>

void InsertSort(int A[],int n){
	int i,j,low,mid,high;
	for(i=2;i<n;i++){//从第二个开始遍历，第一个默认排序好了因为只有一个元素
		A[0]=A[i];//这里A[0]用来存储当前比较的元素，就是书上说的什么哨兵
		low=1;//查找的起始位置
		high=i-1;//结束的位置
		printf("i的值：%d,排序前low:%d,hight:%d   ",i,low,high); //测试
		while(low<=high){//如果low<=high，就继续找呗
			mid=(low+high)/2;//折半
			if(A[mid]>A[0]){//比当前元素大，说明当前元素在A[low]-A[mid]之间
				high=mid-1;//就改变查找的结束位置为mid-1
			}else{//比当前元素大，说明当前元素在A[mid]-A[high]之间
				low=mid+1;//就改变查找的开始位置为mid+1
			}
		}
		printf("low：%d   high:%d      ",low,high); //输出当前的low和high
		for(j=i;j>high;j--){//将下标为high+1后的元素全部后移
			A[j]=A[j-1];//依次后移
		}
		A[high+1]=A[0];//将当前元素放入对应的位置
	}
//	
//	printf("排序结果为："); //输出结果
//	for(i=1;i<n;i++){
//		printf("%d   ",A[i]); 
//	}
}

int main(){
	int A[]={0,5,4,6,2,4,7,8,5,1,9,10};
	InsertSort(A,sizeof(A)/sizeof(A[0]));
	return 0; 
}

1.3 希尔排序

思想：

取一个dk值作为步长，这个dk=n/2(希尔提出的，所以就叫希尔排序了)，把这些间隔dk的元素分为一组在组内进行插入排序。然后接下来令dk_i=dk_(i-1)/2,同样的对于组内的元素进行插入排序。一直这样，到dk=1时，最后对当前序列进行一次插入排序。书上说的是当n在某个特定的范围内时，时间复杂度为O(n^1.3) ,最坏的时间复杂度就是O(n²)。

]

代码：

#include<stdio.h>
 void ShellSort(int A[],int n){
 	int i,j,dk;
 	for(dk=n/2;dk>=1;dk=dk/2){//dk的取值从n/2开始，依次除2，直到1
 		for(i=dk+1;i<n;i++){//控制当前dk循环的次数
 			if(A[i]<A[i-dk]){//说明要进行交换
 				A[0]=A[i];//记录当前的元素
 				for(j=i-dk;j>0&&A[0]<A[j];j-=dk){//令j=i-dk，为了方便交换，表面数组越界
 					A[j+dk]=A[j];	//比A[0]大就后移
 				}
 				A[j+dk]=A[0];	//将A[0]放到对应的下标处
 			}
 		}
 	}	
 		printf("排序结果为："); //输出结果
		for(int k=1;k<n;k++){
			printf("%d   ",A[k]); 
		}
 } 
 
 
int main(){
	int A[]={0,5,4,6,2,4,7,8,5,1,9,10};
	ShellSort(A,sizeof(A)/sizeof(A[0]));
	return 0; 
}

2.交换排序

2.1冒泡排序

思想:

精辟语句：勺比，就一个个硬比

#include<stdio.h>
void BubbleSort(int A[],int n){
 	int i,j;
 	bool flag;
 	for(i=0;i<n;i++){
 		flag=false;
 		for(j=n-1;j>i;j--){
 			if(A[j-1] > A[j]){
 			 	A[j-1]=A[j]+A[j-1];
				A[j]=A[j-1]-A[j];
				A[j-1]=A[j-1]-A[j];	
				flag=true;
 			}
 		}
 		if(flag==false){
 			break;
 		}
 	} 		
 		printf("排序结果为:"); 
		for(int k=0;k<n;k++){
			printf("%d   ",A[k]); 
		}
 } 

int main(){
	int A[]={0,5,4,6,2,4,7,8,5,1,9,10};
	 BubbleSort(A,sizeof(A)/sizeof(A[0]));
	return 0; 
}

2.2快速排序

思想：

快速排序是基于分治算法的。在数组中任取一个值用pivot标记(这个值的下标为i)，在第一次默认取第一个元素作为pivot。然后通过第一个排序使得[0…i-1]都比下标i的元素小，[i+1…n]都比下标i的元素大。当第一次排序完后low和high会重合。

代码：

#include<stdio.h>
//对当前部分元素进行排序
int Partition(int A[],int low,int high){
	int pivot=A[low];//默认让pivot=A[low],就是相当于一个标准吧(以当前的元素为标准)
	while(low<high){//结束的时候是low=high，所以当low<high时进行比较
		while(low<high&&A[high]>=pivot) --high;//如果A[high]>pivot就直接high--,进行下一个元素的比较
		A[low]=A[high];//else即A[high]<pivot时将A[high]赋值给A[low]。实现将比pivot小的元素移动到前面
		while(low<high&&A[low]<=pivot) ++low;//如果A[high]<pivot就直接low++,进行下一个元素的比较
		A[high]=A[low];//else即A[high]>pivot时将A[low]赋值给A[high]。实现将比pivot大的元素移动到后面
	}
	A[low]=pivot;//比较完成将pivot复制给A[low](即low和high最后重合的地方也就是pivot)
	return low;//返回low和high最后重合的地方，即结束的地方的下标
}

//快速排序
void QuickSort(int A[],int low,int high){
	if(low<high){
		int  pivot=Partition(A,low,high);//快排排序
		QuickSort(A,low,pivot-1);//对pivot前面的元素进行排序
		QuickSort(A,pivot+1,high);//对pivot后面的元素进行排序
	}
}

int main(){
	int A[]={0,5,4,6,2,4,7,8,5,1,9,10};
	 QuickSort(A,0,sizeof(A)/sizeof(A[0]));
	  	printf("排序结果为:"); 
		for(int k=0;k<sizeof(A)/sizeof(A[0]);k++){
			printf("%d   ",A[k]); 
		}
	return 0; 
}

3.选择排序

3.1简单选择排序

思想：

就硬找最小的就对了

#include<stdio.h>
void SelectSort(int A[],int n){
	int i,j,min;
	for(i=0;i<n-1;i++){//依次找到最小值,慢的没话说。
		min=i;//标记最小值下标
		for(j=i+1;j<n;j++)//找最小值
			if(A[j]<A[min]) min=j;//min标记最小值的下标
			if(min!=i){
				A[i]=A[i]+A[min];//交换
				A[min]=A[i]-A[min];
				A[i]=A[i]-A[min];
			}		
	}
} 

int main(){
	int A[]={0,5,4,6,2,4,7,8,5,1,9,10};
	SelectSort(A,sizeof(A)/sizeof(A[0]));
	printf("排序结果为:"); 
	for(int k=0;k<sizeof(A)/sizeof(A[0]);k++){
		printf("%d   ",A[k]); 
	}
	return 0; 
}

3.2堆排序

思想：

利用大根堆的性质，根节点大于左右结点的值

代码：

#include<stdio.h>
//构建大根堆 
void HeadAjust(int A[],int i,int len){
	A[0]=A[i];//A[0]想当与一个存储空间用来存储当前的结点的值
	for(int j=i*2;j<=len;j=j*2){//j为他的左孩子结点，j+1为他的又孩子结点
		if(j<len&&A[j+1]>A[j]){//比较A[j]和A[j+1]谁大，如果A[j+1]大，则j++,否则j不变
			j++;
		}
		if(A[j]>A[0]){
			A[i]=A[j];//当前A[j]大于A[0]，就是当前孩子结点中较大的孩子结点大于其父节点时，令父节点的值等于当前的最大值。
			i=j;//这个地方好吧，简直就是绝活(写得好啊)，我画图解释。
		}else{//当前A[j]不大于A[0],就直接结束当前的循环
			break;
		}
	}
	A[i]=A[0];//把A[0]放入对应的位置，究竟是哪一个位置(之所以我没写清楚就是因为，不仅i的下标可能是左孩子还是又孩子的下标，还可能存在别的情况，见图。)
}

void HeapSort(int A[],int len){
    //初始化构建大根堆
	for(int i=len/2;i>0;i--){
		HeadAjust(A,i,len);
	}
    //每次弹出一个元素，相当于这个数组少了一个要进行排序的元素，就对前1-len个元素进行排序即可，因为后面的元素都排好了
	for(int i=len;i>1;i--){
		A[i]=A[i]+A[1];//让最大的元素跟第一个元素交换，使得最大的元素放在当前的数组末尾(当前数组不包括已经怕排好序的)
		A[1]=A[i]-A[1];
		A[i]=A[i]-A[1];
		HeadAjust(A,1,i-1);//让为排序的元素继续形成大根堆
	}
}

int main(){
	int A[]={0,5,4,6,2,4,7,8,5,1,9,10};
	HeapSort(A,sizeof(A)/sizeof(A[0])-1);
	printf("排序结果为:"); 
	for(int k=1;k<sizeof(A)/sizeof(A[0])-1;k++){
		printf("%d   ",A[k]); 
	}
	return 0; 
}

4.归并排序和基数排序

4.1归并排序

思想：

从字面意思来说：归并就是递归+合并。递归当然就是要用递归的思想，合并就是把两个已经排好序的数组进行合并，合并原则就是两个数组都从第一个元素开始比较，用另外的一个数组存储，两个数组中A[i]和B[j]哪个小那个放入辅助数组中，然后若A[i]<B[j]进行i++,反之j++,如果有一个数组已经没有可进行比较的元素，就将另外一个数组剩下的元素依次放入辅助数组中。此时辅助数组就是一个排好序的数组。

代码：

#include<stdio.h>
#include<stdlib.h>//不然用不了malloc
int *B=(int *)malloc(20*sizeof(int));
void Merge(int A[],int low,int mid,int high){//归并,将两个已经排好序的数组进行归并
	int i,j,k;
	for(k=low;k<=high;k++){//辅助辅助数组，将当前这一段要归并排序数组的值给辅助数组
		B[k]=A[k];
	}
	for(i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){//i相当于上面说的第一个数组的下标，j是相当于上面说的第二个数组的下标
		if(B[i]<B[j]){//谁小谁放进去
			A[k]=B[i++];
		}else{
			A[k]=B[j++];
		}
	}
	while(i<=mid) A[k++]=B[i++];//若第一个数组数组(前半段)有剩余元素,则全部依次存入
	while(j<=high) A[k++]=B[j++];//若第二个数组数组(后半段)有剩余元素,则全部依次存入
}

void MergeSort(int A[],int low,int high){
	if(low<high){
		int mid=(low+high)/2;//相当于讲一个数组一分为二，中点
		MergeSort(A,low,mid);//前半段
		MergeSort(A,mid+1,high);//后半段
		Merge(A,low,mid,high);//调用归并
	}
}

int main(){
	int A[]={0,5,4,6,2,4,7,8,5,1,9,10};
	MergeSort(A,0,sizeof(A)/sizeof(A[0])-1);
	printf("排序结果为:"); 
	for(int k=0;k<sizeof(A)/sizeof(A[0]);k++){
		printf("%d   ",A[k]); 
	}
	return 0; 
}

4.2基数排序

思想：

先按各位的大小顺序排，再依次按十位的大小顺序排，再按百味。为什么能够有排序的效果呢(按各位排完序后，这个队列的各位都是从小到大，再按十位排，因为取得时候就已经决定了各位的顺序了，所以十位和各位就排好了，看图更清晰)

5.各种内部排序算法的比较和应用

5.1内部排序算法的比较

		时间复杂度
算法种类	最好情况	平均情况	最坏情况	空间复杂度	是否稳定
直接插入排序	O(n)	O(n²)	O(n²)	O(1)	是
冒泡排序	O(n)	O(n²)	O(n²)	O(1)	是
简单选择排序	O(n²)	O(n²)	O(n²)	O(1)	否
希尔排序				O(1)	否
快速排序	O(nlog₂n)	O(nlog₂n)	O(n²)	O(nlog₂n)	否
堆排序	O(nlog₂n)	O(nlog₂n)	O(nlog₂n)	O(1)	否
2路归并排序	O(nlog₂n)	O(nlog₂n)	O(nlog₂n)	O(n)	是
基数排序	O(d(n+r))	O(d(n+r))	O(d(n+r))	O®	是

5.1内部排序算法的应用

1、若n较小：则可采用直接插入排序或者简单选择排序。由于直接插入排序所需要的记录移动操作比简单选择操作多，因而当记录本身信息量较大时候，用简单选择排序较好。

2、若文件的初试状态基本有序时，用直接插入排序或者冒泡排序较好。

3、若n较大时，应采用时间复杂度为O（nlog2（n））的排序方法，如快速排序，堆排序或者归并排序。快速排序被认可为目前基于比较的内部排序算法中最好的方法。

4、若n很大，记录的关键字位数较小并且可以分解时候，用基数排序最好。

5、当记录本身信息量较大，为避免耗费大量的时间移动记录，可以用链表作为存储结构。