重温排序算法

好久没写程序了，最近年底了比较闲，没事练习下代码，活动下脑子，从排序看起。

    //BubbleSort(Arr, Length);    //10万随机数排序48秒 
    //CocktailSort(Arr, Length);   //10万随机数排序28秒 
    //InsertionSort1(Arr, Length);  //10万随机数排序16秒 
    //QuickSort(Arr, 0, Length-1);  //1亿随机数排序31秒 

从结果来看，快速排序跟其它的不是一个数量级的，但是差异这么多还是我之前没有想到的。

快速排序使用递归函数调用方法，相当于空间换时间。

#include   <stdio.h>

//int   Arr[]   =   {34,   45,   23,   2,   25,   341,   534,   57,   2,   5354,   23421,   1};
//int   Arr[]   =   {1,   2,   3,   4,   5,   6,   7,   8,   9,   10,   11};
//int   Arr[]   =   {11,   10,   9,8,   7,   6,   5,   4,3,   2,   1};
//int   Arr[]   =   {5,6,7,1,2,3,8,0,9,4};
//int   Arr[]   =   {7,5,6,3,2,8,0,9,4,1};
//int   Arr[]   =   {1,   1,   1,   1,   1};
//int   Arr[]   =   {-1,   1,   1,   -100,   0};

#define   NUM   100000
unsigned   int   Arr[NUM];

void   Swap(int   array[],   int   i,   int   j)
{
      int   c   =   0;
      
      c   =   array[i];
      array[i]   =   array[j];
      array[j]   =   c;      
}

/*冒泡法排序*/ 
static   void   BubbleSort(unsigned   int   array[],   unsigned   int   Length)
{
      unsigned   int    i,j,   n,   newn;

      
        for   (i   =   0;   i   <   Length   -   1;   i++)
        {
                newn   =   0;
                n   =   Length;
              
                for   (j   =   0;   j   <   n   -   1;   j++)
                {
                        if   (array[j]   >   array[j   +   1])
                        {
                                Swap(array,   j,   j+1);
                                newn   =   j   +   1;       //   newn   以及之后的元素，都是排好序的
                        }
                }

                n   =   newn;
                if   (n   ==   0)
                {
                        break;
                }
        }
}

/*双向冒泡排序（鸡尾酒排序）*/ 
static   void   CocktailSort(unsigned   int   array[],   unsigned   int   Length)
{
      unsigned   int   begin   =   0;
      unsigned   int   end   =   Length   -   1;
      unsigned   int   newbegin   =   0;
      unsigned   int   newend   =   Length   -   1;
      unsigned   int   i,j,   bSwap;
      
      while(begin   <   end)
      {
            newbegin   =   begin;
            newend   =   end;
            
            bSwap   =   0;
            for(i=begin;   i<end;   i++)
            {
                  if(array[i]   >   array[i+1])
                  {
                        Swap(array,   i,   i+1);
                        newend   =   i+1;
                        bSwap   =   1;
                  }
            }
            
            if(!bSwap)
            {
                  break;
            }

            end   =   newend   -   1;      
            
            bSwap   =   0;
            for(j=end;   j>0;   j--)
            {
                  if(array[j]   <   array[j-1])
                  {
                        Swap(array,   j,   j-1);
                        newbegin   =   j-1;
                        bSwap   =   1;
                  }
            }
            
            if(!bSwap)
            {
                  break;
            }
      
            begin   =   newbegin   +   1;
      }
}

/*插入法排序，后面插入*/
static   void   InsertionSort1(unsigned   int   array[],   unsigned   int   Length)
{
      unsigned   int   i;
      unsigned   int   j;
      
      for(i=Length-1;   i>0;   i--)
      {
            for(j=i;   array[j-1]   >   array[j]   &&   j!=Length;   j++)
            {
                  Swap(array,   j-1,   j);
            }
      } 
}

/*快速排序*/
static   void   QuickSort(unsigned   array[],   long   int   begin,   long   int   end)
{
      long   int   i   =   begin;
      long   int   j   =   end;
      unsigned   int   Pivot   =   begin;
      unsigned   int   Value   =   array[Pivot];
      
      if(begin   >=   end)
      {
            return;
      }
      
      /*默认第一个元素作为标兵，小的数放在标兵前面，大的数放在标兵后面*/
      for(i=begin;   i<=end;   i++)
      {
            if(array[i]   <   Value)
            {
                  /*i-->Pivot-->Pivot+1-->i三个数依次交换位置*/
                  array[Pivot]   =   array[i];
                  array[i]   =   array[Pivot+1];
                  Pivot++   ;
            }
      }
      array[Pivot]   =   Value;
      QuickSort(array,   begin,   Pivot-1);
      QuickSort(array,   Pivot+1,   end);
}


int   main()
{
      time_t   Time;
      unsigned   int   i;
      
      unsigned   int    Length   =   sizeof(Arr)/sizeof(Arr[0]);

      for(i=0;   i<Length;   i++)
      {
            Arr[i]   =   rand(i)   |   rand(i)<<(rand(i)%16)   %   NUM;
      }

      Time   =   time(NULL);
      
      BubbleSort(Arr,   Length);        //10万随机数排序48秒 
      //CocktailSort(Arr,   Length);       //10万随机数排序28秒 
      //InsertionSort1(Arr,   Length);    //10万随机数排序16秒 
      //QuickSort(Arr,   0,   Length-1);    //10万随机数排序少于1秒 
      
      printf("It   spend   %d   Seconeds\n",   time(NULL)   -   Time);
      for(i=0;   i<Length;   i++)
      {
            printf("%d,",   Arr[i]);
      }
      printf("\n");

        return   0;
}