内部排序：直接插入排序、选择排序、冒泡排序、希尔排序、快速排序、堆排序、归并排序代码实现（C语言）

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

//直接插入排序
//排序思想：从第二个元素开始，寻找合适的位置存放该元素，一趟排完 
void DinsertSort(int array[],int n){
	for(int i=1;i<n;i++){//从1开始 
		int temp=array[i];
		int j=i-1;//从i-1位置前面的数字区为有序数字区
		while(j>=0&&temp<array[j]){
			array[j+1]=array[j];
			j--;
		} 
		array[j+1]=temp;
	}
} 
//选择排序二
//排序思想：每次选出一个最小值，放在有序序列右端，n次排序完毕 
void selectSort2(int array[],int n){
	int i,j,k,temp;
	for(i=0;i<n;i++){
		 k=i;//每次选出一个最小值，需要选n次 
		for(j=i+1;j<n;j++){
			if(array[k]>array[j]) k=j;//从第i+1号元素开始， 选出一个最小值 
		}
		temp=array[i];
		array[i]=array[k];
		array[k]=temp;	
	}
} 
//冒泡排序 
//排序思想：每次两两元素进行比较，每次选出一个最大值，放在其最终位置 
void bubleSort(int array[],int n){
	for(int i=n-1;i>=1;i--){//进行n-1趟
	   int flag=0;//标记是否发生交换，若没有发生交换，则排序完毕 
	   for(int j=1;j<=i;j++){
	   	  if(array[j-1]>array[j]){
	   	  	    int temp=array[j];
	   	  	    array[j]=array[j-1];
	   	  	    array[j-1]=temp;
			 	flag=1;    
			 } 
	   }
	   if(flag==0) return; 
		
	} 
} 
//希尔排序
//排序思想：对直接插入排序的一种改进，当序列基本有序时，进行排序时，移动元素次数较直接插入排序少 
void shellSort(int array[],int n){
	for(int gap=n/2;gap>0;gap--){
		for(int i=gap;i<n;i++){
			int temp=array[i];
			int j;
			for(j=i;j>=gap&&array[j-gap]>temp;j-=gap)
			    array[j]=array[j-gap];//有比temp大的元素就往后调，和直接插入排序类似 
			array[j]=temp;    
		}
	}
} 
//快速排序
//排序思想：选一个枢轴元素，将枢轴元素经过一趟排序后放到最终位置，然后将其左半部分和右半部分分别利用递归进行相同操作
void quickSort(int array[],int low,int high){
	int i=low;
	int j=high;
	if(low<high){
		int temp=array[low];
		while(i<j){
			while(i<j&&array[j]>=temp) j--;
			if(i<j){
			array[i]=array[j];
			i++;
			}
			while(i<j&&array[i]<temp) i++;
			if(i<j){
				array[j]=array[i];
				j--;
			}	
		}
		array[i]=temp;
		quickSort(array,low,i-1);
		quickSort(array,i+1,high);	
	}
}


//堆排序
//将序列建成小根堆或大根堆，其比较次数较直接插入排序会少很多 
//先有一个调整堆的函数 
void sift(int array[],int low,int high){
	int i=low;
	int j=2*i+1;
	int temp=array[i];
	while(j<=high){
		if(j<high&&array[j]<array[j+1]) j++;//在左右孩子中挑出较大者
		if(array[j]>temp){
			array[i]=array[j];//将大的元素一直往上调 
			i=j;//将小的元素换下来后，需要再检测是否符合大顶堆，所以需要下移 
			j=2*i+1;
		} else break;
	}
	array[i]=temp;
}
//堆排序 
void heapSort(int array[],int n){
	int i;
	int temp;
	for(int i=n/2-1;i>=0;i--) sift(array,i,n-1);//从非叶节点开始调整成大顶堆 
	for(int i=n-1;i>0;i--){//调整完毕后在堆顶的一定是最大的 ，所以从最后一个结点开始与堆顶元素依次交换， 
		temp=array[0];//交换后再调整为大顶堆，依次进行 
		array[0]=array[i];
		array[i]=temp;
		sift(array,0,i-1);
	} 
}
void PrintArray(int array[],int n){
	printf("a[]:");
	for(int i=0;i<n;i++){	
		printf("%d ",array[i]);
	}
	printf("\n");
}

//归并排序
void merge(int array[],int low,int mid,int high){
	int n1=mid-low+1;
	int n2=high-mid;
	int L1[n1];
	int L2[n2];
	for(int i=0;i<n1;i++){
		L1[i]=array[low+i];//注意点：需要注意+low的含义 
	}
	for(int j=0;j<n2;j++){
		L2[j]=array[mid+1+j];
	}
	int i=0;
	int j=0;
	int k=low;
	while(i<n1&&j<n2){
		if(L1[i]<=L2[j])  array[k++]=L1[i++];
		else array[k++]=L2[j++];
	}	
	while(i<n1)  array[k++]=L1[i++];
	while(j<n2)  array[k++]=L2[j++]; 
} 
//归并排序主函数，利用递归 
void mergeSort(int array[],int low ,int high){
	if(low<high){
		int mid= (low+high)/2;
		mergeSort(array,low,mid);//左半部分进行归并排序 
		mergeSort(array,mid+1,high);//右半部分进行归并排序 
		merge(array,low,mid,high);//将两个归并好的序列合并为一个序列 		
	} 
}
int main(){
	int array[]={1,9,6,4,7,4,5};
	DinsertSort(array,7);
	PrintArray(array,7);
	int array2[]={1,9,6,4,7,4,5};
    selectSort2(array2,7);
    PrintArray(array2,7);
    int array3[]={1,9,6,4,7,4,5};
    bubleSort(array3,7);
    PrintArray(array3,7);
    int array4[]={1,9,6,4,7,4,5,10};
    shellSort(array4,8);
    PrintArray(array4,8);
    int array5[]={1,9,6,4,7,4,5,10,2};
	quickSort(array5,0,8);
	PrintArray(array5,9); 
	int array6[]={1,9,6,4,7,4,5,10,2};
	heapSort(array6,9);
	PrintArray(array6,9);
	int array7[]={1,9,6,4,7,4,5,10,2,8,5,333};
	mergeSort(array7,0,11);
	PrintArray(array7,12);
}

代码运行截图