数据结构(C语言）排序--插入排序--插入折半排序--希尔排序--快速排序

排序

在C语言初级学习中 众所周知了冒泡排序法，选择排序法（擂台排序），介绍一下C中其他的排序方式

插入排序

插入思维简单S(n）=O(n） T（n）=o（n平方）
就是将排序的中小的数拿出，排序到它应该在的位置
因为我们拿出数插入，所以可以将首位单个元素看作一个已经排好序的数组。同时依次插入，依次为排行序的数组（例如第二位进入一次for循环，插入到第一位，此时，前两位就为一个有序表。

void InsertSort(sqList &L){  //插入排序 
   int  i,j;
 for(i=2;i<=L.length;++i)   //从第二位开始，往后 
    if(L.r[i]<L.r[i-1]){      //然后后 小于前一位 
    	L.r[0]=L.r[i];     // 后（该数）赋值给哨兵 
    	L.r[i]=L.r[i-1];   //然后前一位大的数 后移 
    for(j=i-2; L.r[0]<L.r[j];--j)   //前i-2位，大于该数 都后移 
     L.r[j+1]=L.r[j];    //后移 
     L.r[j+1]=L.r[0];    //插人到小于该数的数 后面 
	}
} 

快速排序

 //一趟快速排序 
int Partition(sqList &L,int low,int high){  //LOW为首位1，high为最后一位=length
	L.r[0]=L.r[low];  //low为枢纽, 暂存在0位 
	int pivotkey=L.r[low];  //枢纽记录值 
	 while(low<high){     //从变的两端交替查找，LOW和high相等就停止 
	 while(low<high&&L.r[high]>=pivotkey) --high;
	 L.r[low]=L.r[high];           //将小于枢纽的数移动到低端 
	 while(low<high&&L.r[low]<=pivotkey) ++low;
	 L.r[high]=L.r[low];          //将大于枢纽的数移动到高端 
	 }
	 L.r[low]=L.r[0];     //枢纽记录的数回到空位 
	 return low;          //返回枢纽值 
} 
void QSort(sqList &L,int low ,int high){
	if(low<high){
		int pivotloc=Partition(L,low,high);  //返回为枢纽值 ，枢纽一直使用
		QSort(L,low,pivotloc-1); //对于前面小的表来说， pivotloc是高位（pivotloc不参与再排序） 
		QSort(L,pivotloc+1,high); //对于后面大的表来说， pivotloc是低位 
	}
} 
void QuckSort(sqList &L){  //让函数简洁，对表操作 
	QSort(L,1,L.length);
} 

总实现

#include 
#include 
#define MAXSIZE 20
typedef struct{
	int r[MAXSIZE+1]; //0位为哨兵 
	int length;   //顺序表长度 
}sqList; //顺序表 
void Creat(sqList *L)
{
	int n,e;
	printf("请输入元素个数：");
	scanf("%d",&n);
	L->length=n;  //长度  
	  for(e=1;e<=L->length;e++)  
	 {	
	 getchar();  //让键盘Enter一次，让数据不重叠 
     printf("请输入第%d个数：",e);
     scanf("%d",&(L->r[e]));    }         //输入值 1位开始 
} 
void InsertSort(sqList &L){  //插入排序 
   int  i,j;
 for(i=2;i<=L.length;++i)   //从第二位开始，往后 
    if(L.r[i]<L.r[i-1]){      //然后后 小于前一位 
    	L.r[0]=L.r[i];     // 后（该数）赋值给哨兵 
    	L.r[i]=L.r[i-1];   //然后前一位大的数 后移 
    for(j=i-2; L.r[0]<L.r[j];--j)   //前i-2位，大于该数 都后移 
     L.r[j+1]=L.r[j];    //后移 
     L.r[j+1]=L.r[0];    //插人到小于该数的数 后面 
	}
} 
 //一趟快速排序 
int Partition(sqList &L,int low,int high){  //LOW为首位1，high为最后一位=length
	L.r[0]=L.r[low];  //low为枢纽, 暂存在0位 
	int pivotkey=L.r[low];  //枢纽记录值 
	 while(low<high){     //从变的两端交替查找，LOW和high相等就停止 
	 while(low<high&&L.r[high]>=pivotkey) --high;
	 L.r[low]=L.r[high];           //将小于枢纽的数移动到低端 
	 while(low<high&&L.r[low]<=pivotkey) ++low;
	 L.r[high]=L.r[low];          //将大于枢纽的数移动到高端 
	 }
	 L.r[low]=L.r[0];     //枢纽记录的数回到空位 
	 return low;          //返回枢纽值 
} 
void QSort(sqList &L,int low ,int high){
	if(low<high){
		int pivotloc=Partition(L,low,high);  //返回为枢纽值 ，枢纽一直使用
		QSort(L,low,pivotloc-1); //对于前面小的表来说， pivotloc是高位（pivotloc不参与再排序） 
		QSort(L,pivotloc+1,high); //对于后面大的表来说， pivotloc是低位 
	}
} 
void QuckSort(sqList &L){  //让函数简洁，对表操作 
	QSort(L,1,L.length);
} 
void PrintList(sqList *L)  //输出 
{ int i; 
	  for (i=1;i<=L->length;i++)
    printf(" %d ",L->r[i]);
    printf("\n");
}
int main()
{
sqList L;
Creat(&L);
printf("数组为：\n");	
PrintList(&L);
 InsertSort(L);
 printf("插入排序后，数组为：\n");	
 PrintList(&L);
  QuckSort(L);
  printf("快速排序后，数组为：\n");	
  PrintList(&L);
}

#include 
#include 
#define MAXSIZE 20
typedef struct{
	int r[MAXSIZE+1]; //0位为哨兵 
	int length;   //顺序表长度 
}sqList; //顺序表 
void Creat(sqList *L)
{
	int n,e;
	printf("请输入元素个数：");
	scanf("%d",&n);
	L->length=n;  //长度  
	  for(e=1;e<=L->length;e++)  
	 {	
	 getchar();  //让键盘Enter一次，让数据不重叠 
     printf("请输入第%d个数：",e);
     scanf("%d",&(L->r[e]));    }         //输入值 1位开始 
} 
//插入排序
void InsertSort(sqList &L){   
   int  i,j;
 for(i=2;i<=L.length;++i)   //从第二位开始，往后 
    if(L.r[i]<L.r[i-1]){      //然后后 小于前一位 
    	L.r[0]=L.r[i];     // 后（该数）赋值给哨兵 
    	L.r[i]=L.r[i-1];   //然后前一位大的数 后移 
    for(j=i-2; L.r[0]<L.r[j];--j)   //前i-2位，大于该数 都后移 
     L.r[j+1]=L.r[j];    //后移 
     L.r[j+1]=L.r[0];    //插人到小于该数的数 后面 
	}
} 
//选择排序
int SeletMinKey(sqList &L,int i)
{ int n=i;
 for(;i<=L.length;++i)
 { if(L.r[n]>=L.r[i]){n=i;}
 }
 return n;
}
void SelectSort(sqList &L){
	int i,j,t;
	for(i=1;i<L.length;++i){
		j=SeletMinKey(L,i);
		if(i!=j){
		t=L.r[i];
		L.r[i]=L.r[j];
		L.r[j]=t;}
			}
} 
 //一趟快速排序 
int Partition(sqList &L,int low,int high){  //LOW为首位1，high为最后一位=length
	L.r[0]=L.r[low];  //low为枢纽, 暂存在0位 
	int pivotkey=L.r[low];  //枢纽记录值 
	 while(low<high){     //从变的两端交替查找，LOW和high相等就停止 
	 while(low<high&&L.r[high]>=pivotkey) --high;
	 L.r[low]=L.r[high];           //将小于枢纽的数移动到低端 
	 while(low<high&&L.r[low]<=pivotkey) ++low;
	 L.r[high]=L.r[low];          //将大于枢纽的数移动到高端 
	 }
	 L.r[low]=L.r[0];     //枢纽记录的数回到空位 
	 return low;          //返回枢纽值 
} 
void QSort(sqList &L,int low ,int high){
	if(low<high){
		int pivotloc=Partition(L,low,high);  //返回为枢纽值 ，枢纽一直使用
		QSort(L,low,pivotloc-1); //对于前面小的表来说， pivotloc是高位（pivotloc不参与再排序） 
		QSort(L,pivotloc+1,high); //对于后面大的表来说， pivotloc是低位 
	}
} 
void QuckSort(sqList &L){  //让函数简洁，对表操作 
	QSort(L,1,L.length);
} 

void ShellInsert(sqList &L,int dk){
	int i,j;
	for(i=dk+1;i<=L.length; ++i){
	   if(L.r[i]<L.r[i-dk]){
	   	L.r[0]=L.r[i];
	   	for(j=i-dk;j>0&&L.r[0]<L.r[j];j-=dk)
		   L.r[j+dk]=L.r[j];
		   L.r[j+dk]=L.r[0];   
		   	   }
	}
}
void ShellSort(sqList &L,int dlta[],int t){
	for(int k=0;k<t; ++k)
		ShellInsert(L,dlta[k]);
}

void PrintList(sqList *L)  //输出 
{ int i; 
	  for (i=1;i<=L->length;i++)
    printf(" %d ",L->r[i]);
    printf("\n");
}
int main()
{
sqList L;
Creat(&L);
int a[2]={2,1};
printf("数组为：\n");	
PrintList(&L);

ShellSort(L,a,2);
printf("希尔排序后，数组为：\n");
PrintList(&L);	

    SelectSort(L);
    printf("选择排序后，数组为：\n");
	PrintList(&L);	
  
 InsertSort(L);
 printf("插入排序后，数组为：\n");	
 PrintList(&L);

  QuckSort(L);
  printf("快速排序后，数组为：\n");	
  PrintList(&L);

}