五大排序算法（C语言）

一、 插入排序

        每次将一个待排序的记录按其关键字大小插入到前面已排序好的子序列中，直到全部记录插入完成。

        4        7        2        6        9        13        1        5

        4        7        2        6        9        13        1        5

        2        4        7        6        9        13        1        5

        2        4        6        7        9        13        1        5

        2        4        6        7        9        13        1        5

        2        4        6        7        9        13        1        5

        1        2        4        6        7        9        13        5

        1        2        4        5        6        7        9        13

void InsertSort(int a[],int n){
	int i,j,temp;
	for(i=1;ia[i]){
			temp=a[i];
			for(j=i-1;j>=0&&a[j]>temp;j--){
					a[j+1]=a[j];
			}	
			a[j+1]=temp;
		}
	}
	
}

二、 希尔排序

        先将待排序表分割成若干形如L[ i，i+d，i+2d，...，i+kd ]的“特殊”子表，对各个子表分别进行直接插入排序。缩小增量d，重复上述过程，直到d=1为止。

        4        7        2        6        9        13        1        5

第一次分割

分为 4                                      9                                              （子表1）

                7                                        13                                  （子表2）

                        2                                            1                        （子表3）

                                6                                              5              （子表4）

排序 4                                      9      

                7                                        13

                        1                                            2

                                5                                              6

第二次分割

分为4                  1                  9                  2

                  7                  5                13                  6

排序1                  2                  4                  9

                  5                 6                  7                    13

第三次分割

分为1        5        2        6        4        7        9        13

排序1        2        4        5        6        7        9        13 

void ShellSort(int a[],int n){
	int d,i,j,temp;
	for(d=n/2;d>=1;d=d/2){  //步长变化
		for(i=d;i=0&&temp

三、 冒泡排序

        从前往后（或从后往前）两两比较相邻元素的值，若为逆序，则交换他们，直到序列比较完。

        4        7        2        6        9        13        1        5

第一次冒泡

        4        7        2        6        9        13        1        5

        4        2        7        6        9        13        1        5

        4        2        6        7        9        13        1        5

        4        2        6        7        9        13        1        5

        4        2        6        7        9        13        1        5

        4        2        6        7        9        1         13       5

        4        2        6        7        9        1          5        13 //固定最大的数在最后一位

第二次冒泡

       2        4        6        7        9        1          5        13 

        2        4        6        7        9        1          5        13 

        2        4        6        7        9        1          5        13 

        2        4        6        7        9        1          5        13 

        2        4        6        7        1        9          5        13 

        2        4        6        7        1        5          9        13  //固定第二大的数在倒数第二位

...

void BubbleSort(int a[],int n){
	int i,j,temp;
	for(i=0;ia[j+1]){
				temp=a[j];
				a[j]=a[j+1];
				a[j+1]=temp;
			}
		}
	}
}

四、 快速排序

        在待排序表L[1...n]中任取一个元素作为枢轴（基准），通过一趟排序将待排序表划分为独立的两部分L[1...k-1]和L[k+1...n]，使得L[1...k-1]中的所有元素小于枢轴元素，L[k+1...n]中的所有元素大于等于枢轴元素，则枢轴元素放在了最终位置L(k)上，这一过程称为一次划分。然后分别递归地对两个子表重复上述过程，直至每部分内只有一个元素或空为止，即所有元素放在了其最终位置上。

        4        7        2        6        9        13        1        5

最左侧元素作为枢轴元素

        4

从右至左找比枢轴4小的元素

         -        7        2        6        9        13        1        5  

         -        7        2        6        9        13        1        5  

找到放至空位，空位更新，从左至右找比枢轴大的元素

        1        7        2        6        9        13        -         5

        1        7        2        6        9        13        -         5     

        1        7        2        6        9        13        -         5   

找到放至空位，空位更新，继续刚才的位置至左找比枢轴小的元素 

        1        7        2        -         9        13        6        5                  

        1        7        2        -         9        13        6        5  

两边均到空位，把枢轴元素交给空位，完成一次枢轴元素存放

        1        7        2        4        9        13        6        5 

继续完成左子表和右子表的枢轴元素存放

                         

int Partition(int a[],int low,int high){
	int pivot=a[low]; //第一个元素作为枢轴
	while(low=pivot)high--;
		a[low]=a[high];  //比枢轴小的元素移动到左边
		while(low

     

五、 选择排序

        每一趟在待排序元素中选取关键字最小的元素加入有序子序列

        4        7        2        6        9        13        1        5

        1        7        2        6        9        13        4        5

        1        2        7        6        9        13        4        5

        1        2        4        6        9        13        7        5

        1        2        4        5        9        13        7        6

        1        2        4        5        6        13        7        9

        1        2        4        5        6        7        13        9

        1        2        4        5        6        7        9        13

void SelectSort(int a[],int n){
	int i,j,index,temp;
	for(i=0;i