算法导论的快排(未验证) 深入理解

为什么快速排序能更快呢？

如果每次参考值都是再子数组取得最大最小值，那么跟选择排序有什么差别?

极端的情形有所有的数据都是一样的

如果每次都取得是中间值,最后都分成两个元素的数组 

在有序的情况下，快排性能很差，但是插入排序在数据基本排好的情况下是非常快的。所以我们在用快排之后，等待基本有序就可以用插入排序。

同时递归的时候，使用太多的调用栈会消费太多资源，是的程序运行得很慢，我们《算法导论》使用一种编译程序的优化方法来处理，尾递归。但是我们手动写的尾递归实际效率是差不多的。

算法导论快速排序的主要不同点在与partition，分成三个区间，B有可能不存在，而这个用两个指针，一个A指向小于中间值的子数组里，一个C指向还没有比较处理的值，一经发现符合要求，就马上把他放入的已经确定是小于中间值的数组A后面一个数值交换，实际就是跟biggerArray里面的第一个元素交换，（如果biggerArray不存在，那么A后面第一个元素就是B指向的自己）

smallerArray  (pointer A)

biggerArray B

unSorted   (pointer C)

 到最后，也是重复一个动作来交换A数组后面的第一个元素

View Code 
 #include <stdio.h>
 
 int partition ( int * a , int start , int end )
 {
        int smallerInx = start ;
        int sortedInx     = start - 1;
        int pvot             =  a[end];
         for ( ; unSortedInx  < end;  unSortedInx ++)
       {
                if ( a[unSortedInx ] < pvot )
                {
                           smallerInx ++;
                          swap( a[smallerInx ] , a[unSortedInx]);
                }
       }
       swap( a[smallerInx + 1], a[end]);
      return smallerInx + 1;
 }
 void quickSort ( int * a , int start ,int  end )
 {
       int pvot ;
       if ( start < end )
      {
             quickSort ( a , start, pvot -1);
             quickSort ( a , pvot+1, start);
      } 
 }
 
 int main()
 {
    
 }

  

 

size_t partition( void *base , size_t size , size_t start , size_t end ,(int *(compare(void * ,void *)))

{

    size_t sortedInx = start -1;

    size_t unSortedInx = start;

    void * pvot   = base + end * size ;

    for ( ; unSortedInx < end ; unSortedInx ++)

  {

　　    if( compare(( base + size * unSortedInx ) , pvot) < 0  ) 

        {

　　　　　　　　sortedInx ++;

                      swap( base + size* unSortedInx , pvot);

        }

   

}

      swap ( base + size*(unSortedInx + 1) , pvot);

      return unSortedInx + 1;

}

 

 

int quickSort(void *base , size_t nr , size_t size , (int *(compare(void * ,void *)))

 

 

 

{

 

    _quickSort(base,size, 0, nr-1 , compare);

   return 0;

 

 

 

 

 

}

 

void _quickSort(void *base, size_t size , size_t start , size_t end , compare)

 

 

{

 

　　size_t pvot ;

 

     if ( start < end)

 

 

   {

　　　　pvot = partition ( base , size, start , end , compare);

           _quickSort ( base, size, start, pvot-1);

           _quickSort ( base, size, pvot+1 , end);

 

   }

 

 

 

 

}