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

排序算法

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

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折半插入排序

思路:

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

代码:

# 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的元素分为一组在组内进行插入排序。然后接下来令dki=dk(i-1)/2,同样的对于组内的元素进行插入排序。一直这样,到dk=1时,最后对当前序列进行一次插入排序。书上说的是当n在某个特定的范围内时,时间复杂度为O(n1.3) ,最坏的时间复杂度就是O(n2)。

img]

代码:

#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(n2)O(n2)O(1)
冒泡排序O(n)O(n2)O(n2)O(1)
简单选择排序O(n2)O(n2)O(n2)O(1)
希尔排序O(1)
快速排序O(nlog2n)O(nlog2n)O(n2)O(nlog2n)
堆排序O(nlog2n)O(nlog2n)O(nlog2n)O(1)
2路归并排序O(nlog2n)O(nlog2n)O(nlog2n)O(n)
基数排序O(d(n+r))O(d(n+r))O(d(n+r))

5.1内部排序算法的应用

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

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

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

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

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

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页