C语言实现五大排序算法

1.冒泡排序 
         n个数需进行(n-1)轮排序，轮数从0开始；
         每轮排序需要比较的次数为n-1-i，每轮比较的元素为a[0],a[1],...,a[n-1-i]

         详细算法：

         void sort(int a[],int n)
         {
                 int i,j,t;
                 for(i=0;i<n-1;i++)
                       for(j=0;j<n-1-i)
                            if(a[j]>a[j+1])
                            {
                                  t=a[j];
                                  a[j]=a[j+1];
                                  a[j+1]=t;
                            } 
          }

 

2.选择排序

          n个数需进行(n-1)轮排序，轮数从0开始；

          详细算法：

          void sort(int a[],int n)
          {
                 int i,j,k,t;
 
                 for(i=0;i<n-1;i++)
                 {
                          k=i;//保存i的值，用k来循环排序
                          for(j=i+1;j<n;j++)
                                 if(a[k]>a[j])
                                         k=j;
   
                          t=a[k];
                         a[k]=a[i];
                         a[i]=t;
                 }
          }

 

3.快速排序

           详细算法：

            void quick_sort(int array[], int low, int hight)
            {
                    int i,j,t,m;
                    if(low<hight)
                    {
                           i = low;        //i=0
                           j = hight;      //j=length-1
                           t = array[low]; //t=a[0]
                           while(i<j)
                           {
                                  while(i<j && array[j]>t)//开始和后面的比较，如果后面的比他大继续，如果后面的比它小交换之
                                  {
                                          j--;
                                  }
                                  if(i<j)//在没有越界（i是从前面开始，j是从后面开始）的情况下进行交换
                                  {
                                         m=array[i];
                                         array[i]=array[j];
                                         array[j]=m;
                                  }

                                  while(i<j && array[i]<=t)//和前面的比较，如果前面的小于等于该关键数据继续，如果大于交换之
                                  {
                                           i++;
                                   }
                                   if(i<j)
                                   {
                                           m=array[j];
                                           array[j]=array[i];
                                           array[i]=m;
                                   }
                             }
                             array[i]=t;//第一次比较结束，把i放到中间的位置，也即在i前面都比i小，在i后面都比i大
                             quick_paixu(array, low, i-1);//前面部分实现递归
                             quick_paixu(array, i+1, hight);//后面部分实现递归
                    }
            }

4.直接插入排序

             详细算法：

             void InsertSort(int a[], int n)
             {
                     int i,j,t;
                     for(i=1;i<n;i++)//把a[0]看做已经排序好
                     {
                           t=a[i];//取出一个未排序的数据
                           for(j=i-1;j>=0 && a[j]>t;j--)//在排序序列中查找位置
                                  a[j+1]=a[j];//向后移动元素
                           a[j+1]=t;//插入数据到序列
                      }
              }

5.希尔排序

            详细算法：

            void shellSort(int a[],int len) 
            { 
                  int step; 
                  int i,j,t;  
                  for(step=len/2; step>0;step/=2) //用来控制步长,最后递减到1 
                  {  
                          // i从第step开始排列，应为插入排序的第一个元素 
                          // 可以先不动，从第二个开始排序 
                          for(i=step;i<len;i++)  
                          {  
                                  t=a[i]; 
                                  for(j=i-step;j>=0 && a[j]>t;j-=step) 
                                  { 
                                         a[j+step] = a[j]; 
                                  } 
                                 a[j+step]=t; //将第一个位置填上 
                           }     
                    } 
               }