冒泡排序、选择排序、快速排序、插入排序（希尔排序）、堆排序（十大排序）

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

    

   void traverse_array(int,int *);

   void output_array(int,int *);

   void select_sort_array(int,int *);

   void bubble_sort_array(int,int*);

   void quick_sort_array(int,int[]);

    

   int main()

    {

       int array[]={0,8,2,8,7,5};

       int arr_len=sizeof array /sizeof(int);

        //traverse_array(arr_len,array);

        //select_sort_array(arr_len,array);

        //bubble_sort_array(arr_len,array);

        quick_sort_array(arr_len,array);

        output_array(arr_len,array);

       return0;

    }

    

    //数组反转

   void traverse_array(int argc,int *a)

    {

       int half=argc/2,tmp=0,i;

       for(i=0;i<half;i++)

        {

            tmp=*(a+i);

            *(a+i)=*(a+argc-i-1);

            *(a+argc-i-1)=tmp;

        }

    }

    

    //选择排序

   void select_sort_array(int argc,int *a)

    {

       registerint i,j,min,tmp;

       for(i=0;i<argc;i++)

        {

            min=i;

           for(j=i;j<argc;j++)

            {

               if(a[min]>a[j])

                {

                    min=j;

                }

            }

           if(min!=i)

            {

                tmp=a[i];

                a[i]=a[min];

                a[min]=tmp;

            }

        }

    }

    

//冒泡排序

//它的时间复杂度为O（n^2），虽然不及堆排序、快速排序的O（nlogn，底数为2），但是有两个优点：1.“编程复杂度”很低，很容易写出代码；2.具有稳定性，这里的稳定性是指原序列中相同元素的相对顺序仍然保持到排序后的序列，而堆排序、快速排序均不具有稳定性。

   void bubble_sort_array(int argc,int *a)

    {

       registerint i,j,tmp;

       for(j=0;j<argc-1;j++)

        {

           for(i=0;i<argc-j-1;i++)

            {

               if(a[i]>a[i+1])

                {

                    tmp=a[i];

                    a[i]=a[i+1];

                    a[i+1]=tmp;

                }

            }

        }

    }

    

    //快速排序

//快速排序（Quicksort）是对冒泡排序的一种改进。通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

    //挖坑法

   void quick_sort_array(int argc,int a[])

    {

       int i,j,m=argc-1,tmp,base_num=a[argc-1];

       do

        {

           for(i=0;i<m;i++)

            {

               if(a[i]>=base_num)

                {

                    tmp=a[m];

                    a[m]=a[i];

                    a[i]=tmp;

                    m=i;

                   break;

                }

            }

           for(j=argc-1;j>m;j--)

            {

               if(a[j]<base_num)

                {

                    tmp=a[m];

                    a[m]=a[j];

                    a[j]=tmp;  

                    m=j;  

                   break;  

                }  

            }  

        }while(i!=j);  

       if(m>1)  

        {  

            quick_sort_array(m,a);  

        }  

       if(argc-m-1>1)  

        {  

            quick_sort_array(argc-m-1,a+m+1);  

        }  

       return;  

    }  

    

    //输出数组  

   void output_array(int argc,int *a)  

    {  

       int i;  

       for(i=0;i<argc;i++)  

        {  

            printf("%d ,",a[i]);  

        }  

        printf("\n");  

    }

 /**插入排序法**/

    //插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。

   void Insert_sort(int s[],int len){

       int i,j;

       int temp;

       for(i=1;i<len;i++){

            temp=s[i];

           for (j=i; j>0&&temp<s[j-1]; j--) {

                s[j]=s[j-1];

            }

            s[j]=temp;  

        }  

    }

/**折半插入排序法**/

//当第i个元素要进行排序的时候，它前面的1到i-1位置上的数据是局部有序的，对于有序的数据序列，采用折半查找法去判断在何处插入i位置上的数据，就大大减少了需要比较的次数。

void HalfInsert_sort(int s[],int len){

   int temp, low, high, i, j, mid;

   for (i=1; i<len; ++i)

    {

        temp = s[i];

        low =0;

        high = i -1;

        

       while (high >= low)

        {

            mid = (low + high) /2;

            

           if (temp < s[mid])

            {

                high = mid -1;

            }

            

           else

            {

                low = mid +1;

            }

        }

        

       for (j=i-1; j>=low; --j)

        {

            s[j+1] = s[j];

        }

        

        s[low] = temp;

    }

}

/**希尔排序法**/

//希尔排序法(缩小增量法)属于插入类排序，是将整个无序列分割成若干小的子序列分别进行插入排序的方法。

void Hill_sort(int s[],int len){

   int h,j,k,t;

   for (h=len/2; h>0; h=h/2) {//控制增量

       for (j=h;j<len; j++) {

            t=s[j];

           for (k=j-h; k>=0&&t<s[k]; k-=h) {

                s[k+h]=s[k];

            }

            s[k+h]=t;

        }

    }

}