各种排序的实现 c语言代码实现（插入排序、选择排序、快速排序、堆排序、归并）

👨‍💻过来人学习排序的一点心得：

        刚开始实在理解不了排序的巧妙算法的话，就自己随机列一个数组，不需要太长，五六个数即可，按照代码运行顺序，一步一步不要偷懒的在脑子里或纸上把排序过程从头到尾理一遍，十遍二十遍就有感觉了；找到感觉之后，再找一些特殊案例，如完全倒序的数排成正序、快排的临时值选数组第一个或末尾的情况等；再回过来整体看算法架构，就能清楚的理解了

常用排序的C语言实现（插入排序、选择排序、快速排序、堆排序、归并）

排序可视化网站：Comparison Sorting Visualization

1.快排（重点）

（1）算法思想

选择一个基准元素，将比基准元素小的元素放在其前面，比基准元素大的元素放在其后面，然后在将小于基准值元素的子数列和大于基准元素的子数列按原来的方法排序，直到整个序列有序;

（2）优缺点

优点：极快数据移动少；

缺点：不稳定；

（3）效率分析

此排序算法的效率在序列越乱的时候，效率越高。在数据有序时，会退化成冒泡排序；

2.冒泡排序（重点）

（1）基本原理

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现他们的排序与排序要求相反时，就将他们互换。

（2）优缺点

优点：稳定

缺点：慢，每次只能移动两个相邻的数据；

3.插入排序（重点）

（1）基本思想

将一个记录插入到已排序好的有序表中，从而得到一个新的，记录数增1的有序表。即先将序列的第一个记录看成是一个有序的子序列，然后从第二个记录逐个进行插入，直至整个序列有序为止。

（2）优缺点

优点：稳定，快

缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是数据量庞大的时候

4.堆排序

4.1、二叉堆定义：

二叉堆是完全二叉树或近似完全二叉树。二叉堆满足两个特性:

（1）父结点的键值总是大于或者等于（小于或者等于）任何一个子节点的键值；

（2）每个结点的左子树和右子树都是一个二叉堆；

当父结点的键值总是大于或者等于任何一个子节点的键值时为大根堆。当父结点的键值总是小于或等于任何一个子节点的键值时为小根堆；

4.2、堆的存储：

一般都用数组来表示堆，i结点的父结点下标就为（i-1）/2.它的左右子节点的下标分别为2*i+1和2*i+2.

4.3、堆的插入：

每次插入都是将新数据放在数组最后。可以发现从这个新数据的父结点到根结点必然为一个有序的数列，然后将这个新数据插入到这个有序数据中

（1）用大根堆排序的基本思想

先将初始数组建成一个大根堆，此对为初始的无序区；

再将最大的元素和无序区的最后一个记录交换，由此得到新的无序区和有序区，且满足<=的值；

由于交换后新的根可能违反堆性质，故将当前无序区调整为堆。然后再次将其中最大的元素和该区间的最后一个记录交换，由此得到新的无序区和有序区，且仍满足关系的值<=的值，同样要将其调整为堆；

..........

直到无序区只有一个元素为止；

4.4：应用

寻找M个数中的前K个最小的数并保持有序；

时间复杂度：O(K)[创建K个元素最大堆的时间复杂度] +（M-K）*log(K)[对剩余M-K个数据进行比较并每次对最大堆进行从新最大堆化]

5.希尔排序

（1）基本思想

先将整个待排序元素序列分割成若干子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序（因为直接插入排序在元素基本有序的情况下，效率很高）；

（2）适用场景

比较在希尔排序中是最主要的操作，而不是交换。用已知最好的步长序列的希尔排序比直接插入排序要快，甚至在小数组中比快速排序和堆排序还快，但在涉及大量数据时希尔排序还是不如快排；

6.归并排序

（1）基本思想

首先将初始序列的n个记录看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2个长度为2的有序子序列，在此基础上，再对长度为2的有序子序列进行两两归并，得到若干个长度为4的有序子序列，以此类推，直到得到一个长度为n的有序序列为止；

（2）适用场景

若n较大，并且要求排序稳定，则可以选择归并排序；

7.简单选择排序（重点）

（1）基本思想

第一趟：从第一个记录开始，将后面n-1个记录进行比较，找到其中最小的记录和第一个记录进行交换；

第二趟：从第二个记录开始，将后面n-2个记录进行比较，找到其中最小的记录和第2个记录进行交换；

...........

第i趟：从第i个记录开始，将后面n-i个记录进行比较，找到其中最小的记录和第i个记录进行交换；

以此类推，经过n-1趟比较，将n-1个记录排到位，剩下一个最大记录直接排在最后；

#define len 11											//随机数组长度 
#include <stdio.h>
#include <stdlib.h>

// 写两个用于遍历的函数
void B (int a[]);//遍历数组 从0位开始
void B2(int a[]);//遍历数组 从1位开始 

void InsertSort(int a[],int n);							//直接插入排序 (哨兵)
void HalfInsertSort(int a[],int n);						//折半插入 
void BubbleSort(int a[],int n);							// 冒泡 小到大 
void QuickSort(int a[],int low,int high);				//快排 
void SelectSort(int a[],int n);							//选择排序，选择小 

// 是的，堆排序需要三个函数
void BuildMaxHeap(int a[],int n);						//建立大顶堆 
void HeadAdjust(int a[],int k,int n);					//堆调整 
void HeapSort(int a[],int n);							//堆排序主函数 

// 归并也需要三个函数
void MergeSort(int a[],int b[],int low,int high);		//归并递归函数 
void Merge(int a[],int b[],int low,int mid,int high);	//归并核心代码 
void GuiBing(int a[],int low,int high);					//归并排序 

int main()
{
	int a[len]={0,};//设第一个元素为0，部分函数需要哨兵 
	printf("原随机数组为："); 
    printf("%d,", a[0]);
	for(int i=1;i<len;++i)  // 已经定义过len=11，循环为1-10
		//生成0~100的随机数 
		printf("%d，",   a[i]=rand()%101);
	printf("\n");
	
	 
	//在这里使用排序函数 
	InsertSort(a,len);
	HalfInsertSort(a,len);
	BubbleSort(a,len);
	QuickSort(a,0,len-1);	B(a);	    //快排有递归，手动输出 
	SelectSort(a,len);
	HeapSort(a,len-1);
	GuiBing(a,0,len-1);					//也可以使用MergeSort后手动输出 
								


	
	return 0;
}


void B(int a[]){   //从0位开始遍历数组 
//printf("排序后数组为："); 
	for(int i=0;i<len;i++)
		printf("%d，",a[i]);
		printf("\n");
}
void B2(int a[]){  //从0位开始遍历数组 
//printf("排序后数组为："); 
	for(int i=1;i<len;i++)
		printf("%d，",a[i]);
		printf("\n");
}

void InsertSort(int a[],int n){    //直接插入排序 
	printf("直接插入排序："); 
	int i,j;
	for(i=2;i<n;i++)					//从第二个开始循环
		if(a[i]<a[i-1]){				//若后一个比前边小，则交换，否则略过 
			a[0]=a[i];					//a[0]设为哨兵，暂存待排序的那个数，不参与关键字 
			for(j=i;a[0]<a[j-1];j--)	//从待排序前边那个数开始依次往后移动一位，覆盖了待排a[j] 
				a[j]=a[j-1];
			a[j]=a[0];				//j退出for后少1，加上1为i位置 
	} //if 
		B2(a);
}

void HalfInsertSort(int a[],int n){//折半插入排序 
	printf("折半插入排序："); 
	int i,j,low,high,mid;
	for(i=2;i<n;++i)
	if(a[i]<a[i-1]){
		a[0]=a[i];
		low=0;high=i-1;
		while(low<=high){				//也就这一步找插入位置不一样， 
			mid=(low+high)/2;			//可以降低一点查找时间，其它和直插一样
			if(a[mid]>a[0]) high=mid-1;
			else low=mid+1;
		}
		for(j=i;a[0]<a[j-1];j--)
			a[j]=a[j-1];
		a[j]=a[0];
	}
		B2(a);
}

void BubbleSort(int a[],int n){//冒泡排序（大的往后） 
	printf("冒泡排序后为："); 
	int swap=0,i,j,temp;       
	for(j=n-1;j>0;--j){
		swap=0;
		for(i=0;i<j;++i)
			if(a[i]>a[i+1]){
				temp=a[i];
				a[i]=a[i+1];
				a[i+1]=temp;
				swap=1;
			}
			if(swap==0)
			 break;
	}
		B(a);
}

void QuickSort(int a[],int low,int high){//快速排序 
	int temp,i=low,j=high;
	temp=a[low];
	if(i<j){
		while(i!=j){
			while(i<j&&a[j]>temp) j--;
			if(i<j)
				a[i++]=a[j];
			
			while(i<j&&a[i]<temp) i++;
			if(i<j)
				a[j--]=a[i];
		}
		a[i]=temp;
		QuickSort(a,low,i-1 );
		QuickSort(a,i+1,high);
	}
	
	
}

void SelectSort(int a[],int n){//简单选择排序 
	printf("简单选择排序："); 
	int min=0,temp,i,j;
	for(j=0;j<n;++j){
		min=j;  // 不断找到最小值，提到前边
		for(i=j;i<n;++i)
			if(a[i]<a[min]) 
				min=i;
		temp=a[min];
		a[min]=a[j];
		a[j]=temp;
	}
		B(a);
}

void BuildMaxHeap(int a[],int n){//建立大顶堆 
	for(int i=n/2;i>0;i--)			//从一半处不断调整堆 
		HeadAdjust(a,i,n);
}
void HeadAdjust(int a[],int k,int n){//将元素k为根的子树调整 
	a[0]=a[k];							//a[0]暂存子树的根节点 
	for(int i=2*k;i<=n;i*=2){
		if(i<n&&a[i]<a[i+1])
		i++;
		if(a[0]>a[i]) break;
		else{
			a[k]=a[i];
			k=i;
		}
	}
	a[k]=a[0];
}

void HeapSort(int a[],int n){//堆排序 len-1 
	printf("堆排序后为  ："); 
	BuildMaxHeap(a,n);
	int temp;
	for(int i=n;i>1;--i){
		temp=a[i];
		a[i]=a[1];
		a[1]=temp;
		HeadAdjust(a,1,i-1);
	}
	B2(a);
}

void Merge(int a[],int b[],int low,int mid,int high){//归并两段a 
	
	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++){
		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 b[],int low,int high){//归并排序 
	if(low<high){
		int mid=(low+high)/2;
		MergeSort(a,b,low,mid);
		MergeSort(a,b,mid+1,high);
		Merge(a,b,low,mid,high);
	}
	
}

void GuiBing(int a[],int low,int high){
	printf("二路归并排序："); 
		int *b=(int *)malloc((len)*sizeof(int));
	MergeSort(a,b,low,high);
	B2(a);
}