各种排序算法实现（以数组为数据结构）（可运行）：直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序

各种排序算法实现（以数组为数据结构）（可运行）：直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序

#include<stdio.h>
#include<stdbool.h> 

//直接插入排序
void StraightInsertSort1(int a[],int n){
	int i,j,temp;
	for(i=1;i<n;i++)//将各元素插入到已排好的序列中，从第二个元素开始 
	{
	    if(a[i]<a[i-1])//若A[i]关键字小于前驱 
		{
			temp=a[i];//temp暂存A[i]
			for(j=i-1;j>=0&&a[j]>temp;j--)//检查所有前面已排好的元素 
			{
				a[j+1]=a[j];//所有大于temp的元素都向后移位 
			} 
			a[j+1]=temp;//temp插入 
		} 
	}
} 

//直接插入排序（带哨兵）
void StraightInsertSort2(int a[],int n)
{//带哨兵与不带哨兵的不同：a[0]用来取代临时存储变量temp,待排序元素从下标1
//开始存储，循环判断从下标2开始。并且不用再循环判断j>=0 
	int i,j;
	for(i=2;i<=n;i++)//依次将a[2]~a[n]插入前面已排好的序列,初始已排好的序列只有a[1] 
	{
		if(a[i]<a[i-1]){
			a[0]=a[i];
			for(j=i-1;a[0]<a[j];j--)
				a[j+1]=a[j];
			a[j+1]=a[0];		
		}
	}	
} 

//折半插入排序(带哨兵)
void BinaryInsertSort(int a[],int n)
{//因为插入排序分为两个部分，前部分为已经排序好的序列，所以可以使用
//折半查找提升查找到后半部分第一个元素的插入位置。 
	int i,j,low,high,mid;
	for(i=2;i<=n;i++)//依次将a[2]~a[n]插入前面已排好的序列 
	{
		a[0]=a[i];
		low=1;
		high=i-1;//待查找的元素的前一个，有序序列的最后一个元素 
		while(low<=high)
		{
			mid=(low+high)/2;
			if(a[0]>=a[mid])//原始的插入排序分为三个部分，这里的要求a[0]>a[mid] 
			//并且a[0]=a[mid],是为了保证排序的稳定性。相等的情况low要继续向后移动 
				low=mid+1;	
			else
				high=mid-1; 
		} 
		for(j=i-1;j>=low;j--)
			a[j+1]=a[j];
		a[low]=a[0];
	} 
}

//希尔排序(带哨兵) 
//先追求表中元素的部分有序，再逐渐逼近全局有序
void ShellInsert(int a[],int n,int gap)
{//进行一次增量为gap的插入排序。 
	int i,j;
	for(i=gap+1;i<=n;i++)//从分表的第二个元素开始判断 
	{
		if(a[i]<a[i-gap])//如果a[i]小于分表的有序部分的最后一个元素(最大的元素)	
		{
			a[0]=a[i];
			for(j=i-gap;j>0&&a[0]<a[j];j=j-gap)
			{
				a[j+gap]=a[j];//元素后移 
			} 
			a[j+gap]=a[0]; 
		}	
	} 
} 

void ShellSort(int a[],int gaps[],int n,int t)
{//n为a数组的长度,t为gaps数组的长度。当gaps只有一个值且为1时，就是直接插入排序 
	int k;
	for(k=0;k<t;k++)
		ShellInsert(a,n,gaps[k]);	
}

//冒泡排序(带哨兵)
void BubbleSort(int a[],int n)
{
	int i,j;
	for(i=1;i<=n-1;i++)
	{
		bool flag=false;//判断本趟是否交换了元素。如果没有交换元素，就代表
		//数组元素已经提前有序了
		for(j=2;j<=n-i+1;j++)//每次找出最大元素放在无序序列的最后面 
		{
			if(a[j-1]>a[j])
			{ 
				a[0]=a[j-1];
				a[j-1]=a[j];
				a[j]=a[0];
			}
			flag=true;		
		}	
		if(flag==false)
			break;
	}	
} 

//进行一趟快速划分，将待排序序列划分成两个部分。 
int Partition(int a[],int low,int high)
{
	a[0]=a[low];//哨兵存放基准元素
	while(low<high)//结束循环之后low==high,low/high指向的就是基准元素存放的位置
	{
		//high向左移 
		while(low<high&&a[high]>=a[0])//在low小于high的条件下一直搜索，直到出现
			high--;
		//high指向的值小于a[0]的时候退出循环。此时，high指向的是小于a[0]的元素。
		a[low]=a[high];//将小于a[0]的元素移到左端
		//low向右移 
		while(low<high&&a[low]<=a[0])//当low指向的值大于a[0]时退出循环。
			low++;
		//此时low指向的是比a[0]大的元素。
		a[high]=a[low];//将大于a[0]的元素移到右端,a[high]存放的数据是无用的，将
		//a[low]赋值给a[high]; 	 
	}	
	a[low]=a[0];//此时low和high的值相等，就是基准元素a[0]要放的位置 
	return low; //返回存放基准元素的位置，也可以是return high; 
} 

//快速排序(带哨兵)
void QuickSort(int a[],int low,int high)
{
	if(low<high)
	{
		int pivotpos=Partition(a,low,high);//划分
		//此时，pivotpos为基准元素的位置，也是该元素的正确位置，不能动。
		//对该元素左右部分进行划分。 
		QuickSort(a,low,pivotpos-1);//划分左子表 
		QuickSort(a,pivotpos+1,high);//划分右子表 
	} 
} 


//简单选择排序：每一趟在待排序元素中找到关键字最小的元素，加入到有序子序列
void SelectSort(int a[],int n)
{
	int i,j;
	for(i=1;i<=n;i++)
	{
		int min=i;//min存放该趟最小元素的下标	
		for(j=i+1;j<=n;j++)//在i+1到n中选取最小元素 
		{
			if(a[j]<a[min])
				min=j;//最小元素下标赋给min 
		}	
		if(min!=i)//如果a[min]就是最小元素，没有发生上面的赋值，不用交换 
		{
			a[0]=a[min];//a[0]是哨兵 
			a[min]=a[i];
			a[i]=a[0];
		} 
	}	
} 

//将以k为根的子树调整为大根堆。每次调用仅对k这个元素的及其子树调整到大根堆 
void HeadAdjust(int a[],int k,int len)
{
	int i;
	a[0]=a[k];//a[0]暂存子树的根结点 
	for(i=2*k;i<=len;i=i*2)//沿着key的较大的子节点向下筛选 
	{
		if(i<len&&a[i]<a[i+1])
			i++;		//选出子结点值较大的下标 
		if(a[0]>=a[i])//筛选结束 
			break;
		else{ 
			a[k]=a[i];//将a[i]调整到双亲节点上 
			k=i;//修改k值，以便继续向下筛选 
		} 
	}
	//调整结束后，将原始根结点放入到最终的正确位置 
	a[k]=a[0]; 
} 

//对整个序列建大根堆：对前n/2个元素建立大根堆 
void BuildMaxHeap(int a[],int len)
{
	int i;
	for(i=len/2;i>=1;i--)//从最后一个有子树的元素开始调整，直到根结点
	{
		HeadAdjust(a,i,len);
	}
}

//堆排序：初始序列为数的层序遍历系列。初始时，先建立大根堆。
void HeapSort(int a[],int len)//数组元素从1开始 
{
	int i;
	BuildMaxHeap(a,len);//初始建堆,此时最大的元素在a[1] 
	for(i=len;i>1;i--)//当i=1时，只有一个元素，不需要在调整为大根堆 
	{
		//将最大元素和最后一个元素交换，使最大元素变成最后一个元素，得到正确位置 
		a[0]=a[1];
		a[1]=a[i];
		a[i]=a[0];
		HeadAdjust(a,1,i-1);//将剩余的待排序元素整理成堆 
	} 
}

//归并排序
void Merge(int a[],int low,int mid,int high)
{
	int i,j,k,b[100];
	for(i=low;i<=high;i++)
		b[i]=a[i];//将a中所有元素复制到b中
	i=low;//i指向左半部分第一个元素 
	j=mid+1;//j指向右半部分第一个元素 
	for(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 low,int high)
{
	if(low<high)//最先排序好的是最小的子部分。从下到上，由部分有序到整体有序 
	{
		int mid=(low+high)/2;//从中间划分 
		MergeSort(a,low,mid);//mid是左半部分最后一个元素
		MergeSort(a,mid+1,high);
		Merge(a,low,mid,high);//归并 
	}
} 
 
int main(){
	int array[10];
	int i,enter=1,select;
	int a[11];
	printf("请输入要排序的序列(10个元素)：\n");
	for(i=1;i<=10;i++)
		scanf("%d",&a[i]); 
	while(enter!=9)
	{
		printf("\n\n\t\t****************排序*************\n");
		printf("\t\t          1、直接插入排序\n");
		printf("\t\t          2、折半插入排序\n");
		printf("\t\t          3、希尔排序\n");
		printf("\t\t          4、冒泡排序\n");
		printf("\t\t          5、快速排序\n");
		printf("\t\t          6、简单选择排序\n");
		printf("\t\t          7、堆排序\n");
		printf("\t\t          8、归并排序\n");
		printf("\t\t          9、退出系统\n");
		printf("请输入排序序号：");
		scanf("%d",&select); 
		switch(select)
		{
			case 1:
				StraightInsertSort2(a,10);
				break;	
			case 2:
				BinaryInsertSort(a,10);
				break;
			case 3:{
				int gap[]={4,2,1};
				ShellSort(a,gap,10,3);
				break;
			}	
			case 4:
				BubbleSort(a,10);
				break;
			case 5:
				QuickSort(a,1,10);
				break;
			case 6:
				SelectSort(a,10);
				break;
			case 7:
				HeapSort(a,10);
			case 8:
				MergeSort(a,1,10);			
		}
		printf("排序结果为：");
		for(i=1;i<=10;i++)
			printf("%d ",a[i]);
		printf("\n");
		printf("请选择是否退出：9：退出；其他：继续：");
		scanf("%d",&enter);
	}  
	return 0; 
} 

运行结果：

1、直接插入排序

2、折半插入排序

3、希尔排序

4、冒泡排序

5、快速排序

6、简单选择排序

7、堆排序

8、归并排序