快速排序（编程珠玑）

快速排序（编程珠玑）

编程珠玑第二版快速排序

 1  qsort4( 0 , n - 1 );
 2  isort3();
 3 
 4  void  qsort4(l, u)
 5  {  
 6        if  (u  -  l  <  cutoff)                // cutoff是一个小整数，如果要排序的数组很小，可以用插入排序，速度更快
 7           return ;
 8         swap(L, randint(l, u))       // 将第一个数据与后面的数据随即交换，避免要排序的数据已是升序排列或者第一个数据很小
 9         t  =  x[l];                             // t为中间元素，所有数据与其进行比较，小于t的放到左边，大于t的放到右边
10         i  =  l;
11        j  =  u + 1 ;
12        loop
13                 do  
14                {
15                       i ++ ;
16                }  while  (i  <=  u  &&  x[i]  <  t);      // 从第二个数据开始比较，遇到大于t的数据终止循环
17 
18                 do  
19                {
20                       j -- ;
21                 }  while  (x[j]  >  t);      // 从最后一个数据进行比较，遇到小于t的终止循环
22 
23                 if  (i  >  j)           // 如果i>j，数据分组成功，跳出循环
24                        break ;
25                temp  =  x[i];     // 交换上面两个循环终止时的数据
26                x[i]  =  x[j];
27                x[j]  =  temp;
28 
29         swap(l, j);            // 交换x[i]与x[j]的值，分组完成
30         qsort4(l, j - 1 );      // 排序小于t的数据
31         qsort4(j + 1 , u);    // 排序大于t的数据 
32  }
33 
34  void  isort3()  // 插入排序，当排序的数据很少时可以用此排序
35  {
36          int  i,j;
37          for  i  =  [l, n)
38             t  =  x[i];
39              for  (j = i; j > 0   &&  x[j - 1 ] > t; j -- )
40             {
41                    x[j]  =  x[j - 1 ];
42             }
43             x[j]  =  t;
44    }

转自：http://www.cppblog.com/humanchao/archive/2008/08/18/59241.html

Quick Sort C Code Implement

void  QuickSort( int *  pData, int  left, int  right)
{
     int  i  =  left, j  =  right;
     int  middle  =  pData[(left + right) / 2 ];         //  midlle value
     int  iTemp;
     do
    {    
         while  (pData[i]  <  middle  &&  i  <  right)            i ++ ;
         while  (pData[j]  >  middle  &&  j  >  left)            j -- ;
         if  (i  <  j)                             //  swap
        {
            iTemp     =  pData[i];
            pData[i]  =  pData[j];
            pData[j]  =  iTemp;
            i ++ ;            j -- ;
        } 
         else   if  (i  ==  j)
        {
            i ++ ;            j -- ;
        }
    }  while  (i  <  j);

     if  (left   <  j)        QuickSort(pData,left,j);
     if  (right  >  i)        QuickSort(pData,i,right);
}

 

堆排序实现原理

转自：http://www.nowamagic.net/algorithm/algorithm_HeapSortStudy.php

堆排序C语言描述

　　

 1  //  array是待调整的堆数组，i是待调整的数组元素的位置，nlength是数组的长度 
 2  　　 void  HeapAdjust( int  array[], int  i, int  nLength)  // 本函数功能是：根据数组array构建大根堆 
 3  　　{ 
 4  　　       int  nChild; 
 5  　　       int  nTemp; 
 6  　　       for  (nTemp  =  array[i];  2   *  i  +   1   <  nLength; i  =  nChild) 
 7  　　      { 
 8  　　             //  子结点的位置=2*（父结点位置）+ 1 
 9  　　            nChild  =   2   *  i  +   1 ; 
10  　　             //  得到子结点中较大的结点 
11  　　             if  (nChild  <  nLength  -   1   &&  array[nChild  +   1 ]  >  array[nChild]) 
12  　　             ++ nChild; 
13  　　             //  如果较大的子结点大于父结点那么把较大的子结点往上移动，替换它的父结点 
14  　　             if  (nTemp  <  array[nChild]) 
15  　　            { 
16  　                  　array[i] =  array[nChild]; 
17  　            　} 
18  　　             else 　 //  否则退出循环 
19  　　            { 
20  　　                   break ; 
21  　　            } 
22  　　             //  最后把需要调整的元素值放到合适的位置 
23  　　            array[nChild] =  nTemp; 
24  　      　} 
25  　　} 
26  　　 //  堆排序算法 
27  　　 void  HeapSort( int  array[], int  length) 
28  　　{ 
29  　　         //  调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素 
30  　　       for  ( int  i  =  length  /   2   -   1 ; i  >=   0 ;  -- i) 
31  　　      { 
32  　　            HeapAdjust(array,i,length); 
33  　      　} 
34  　　       //  从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素 
35  　　       for  ( int  i  =  length  -   1 ; i  >   0 ;  -- i) 
36  　　      { 
37  　            　 //  把第一个元素和当前的最后一个元素交换， 
38  　            　 //  保证当前的最后一个位置的元素都是在现在的这个序列之中最大的 
39  　            　Swap( & array[ 0 ], & array[i]); 
40  　　             //  不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值 
41  　　            HeapAdjust(array, 0 ,i); 
42  　　      } 
43  　　} 

堆排序算法（C++描述）

 1  #define  MAX 100 // 数据元素的最大个数 
 2  　　typedef  struct  
 3  　　{ 
 4  　　       int  r[MAX]; 
 5  　　       int  length; 
 6  　　}SqList; // 定义一个线性表用于存放数据元素 
 7  　　 void  HeapAdjust(SqList  & L, int  s, int  m) 
 8  　　{
 9               // 已知L.r[sm]中记录除L.r[s]外均满足堆的定义，本函数用于使L.r[sm]成为一个大顶堆 
10  　　       int  j; 
11  　      　 int  e = L.r[s]; 
12  　      　 for (j = 2 * s;j <= m;j *= 2 ) 
13  　      　{ 
14  　            　 if (j < M && L.R[J] < L.R[J + 1 ])  ++ j; 
15  　　             if (e >= L.r[j])  break ; 
16  　　            L.r[s] = L.r[j]; 
17  　            　s = j; 
18  　      　} 
19  　　      L.r[s] = e; 
20  　　} 
21  　　 void  HeapSort(SqList  & L) 
22  　　{
23               // 对顺序表L进行堆排序 
24  　　       int  i,e; 
25  　　       for (i = L.length / 2 ;i > 0 ;i -- ) 
26  　　            HeapAdjust(L,i,L.length); 
27  　　       for (i = L.length;i > 1 ;i -- ) 
28  　      　{
29                     // 将大顶堆的顶记录和最后一个记录相互交换 
30  　            　e = L.r[ 1 ]; 
31  　            　L.r[ 1 ] = L.r[i]; 
32  　　            L.r[i] = e; 
33  　　            HeapAdjust(L, 1 ,i - 1 ); 
34  　      　} 
35  　　}