排序方法小结（c++版）

 

1. void shellsort( vector<int> & a )
2. {
3.     for( int gap = a.size( ) / 2; gap > 0; gap /= 2 )
4.         for( int i = gap; i < a.size( ); i++ )
5.         {
6.             int tmp = a[ i ];
7.             int j = i;
9.             for( ; j >= gap && tmp < a[ j - gap ]; j -= gap )
10.                 a[ j ] = a[ j - gap ];
11.             a[ j ] = tmp;
12.         }
13. }
15. //堆排序
16. inline int leftChild( int i )
17. {
18.     return 2 * i + 1;
19. }
21. void percDown( vector<int> & a, int i, int n )
22. {
23.     int child;
24.     int tmp;
26.     for( tmp = a[ i ]; leftChild( i ) < n; i = child )
27.     {
28.         child = leftChild( i );
29.         if( child != n - 1 && a[ child ] < a[ child + 1 ] )
30.             child++;
31.         if( tmp < a[ child ] )
32.             a[ i ] = a[ child ];
33.         else
34.             break;
35.     }
36.     a[ i ] = tmp;
37. }
39. void heapsort( vector<int> & a )
40. {
41.     for( int i = a.size( ) / 2; i >= 0; i-- )  
42.         percDown( a, i, a.size( ) );
43.     for( int j = a.size( ) - 1; j > 0; j-- )
44.     {
45.         swap( a[ 0 ], a[ j ] );              
46.         percDown( a, 0, j );
47.     }
48. }
51. //归并排序
52. void merge( vector<int> & a, vector<int> & tmpArray,
53.             int leftPos, int rightPos, int rightEnd )
54. {
55.     int leftEnd = rightPos - 1;
56.     int tmpPos = leftPos;
57.     int numElements = rightEnd - leftPos + 1;
59.     while( leftPos <= leftEnd && rightPos <= rightEnd )
60.         if( a[ leftPos ] <= a[ rightPos ] )
61.             tmpArray[ tmpPos++ ] = a[ leftPos++ ];
62.         else
63.             tmpArray[ tmpPos++ ] = a[ rightPos++ ];
65.     while( leftPos <= leftEnd )   
66.         tmpArray[ tmpPos++ ] = a[ leftPos++ ];
68.     while( rightPos <= rightEnd )  
69.         tmpArray[ tmpPos++ ] = a[ rightPos++ ];
72.     for( int i = 0; i < numElements; i++, rightEnd-- )
73.         a[ rightEnd ] = tmpArray[ rightEnd ];
74. }
77. void mergesort(vector<int> & a,vector<int> &tmpArray,int left,int right)
78. {
79.     if ( left < right )
80.     {
81.      int center = ( left+right ) / 2;
82.      mergesort( a, tmpArray, left, center);
83.      mergesort( a, tmpArray, center+1, right);
84.      merge( a, tmpArray, left, center+1, right);
85.     }
86. }
88. void mergesort( vector<int> & a )
89. {
90.    vector<int> tmpArray( a.size() );
91.    mergesort( a, tmpArray, 0, a.size()-1 );
93. }
95. //快速排序
96. const int & median3( vector<int> & a, int left, int right )
97. {
98.     int center = ( left + right ) / 2;
99.     if( a[ center ] < a[ left ] )
100.         swap( a[ left ], a[ center ] );
101.     if( a[ right ] < a[ left ] )
102.         swap( a[ left ], a[ right ] );
103.     if( a[ right ] < a[ center ] )
104.         swap( a[ center ], a[ right ] );
106.         // Place pivot at position right - 1
107.     swap( a[ center ], a[ right - 1 ] );
108.     return a[ right - 1 ];
109. }
111. void  insertionSort( vector<int> & a,int left,int right )
112. {
113.     int j;
115.     for( int p=left; p<right; p++)
116.     {
117.      int tmp = a[ p ];
118.      for( j=p; j>0 && tmp<a[ j-1 ]; j--)
119.          a[ j ]=a[ j-1 ];
120.      a[ j ] = tmp;
121.     
122.     }
124. }
126. void quicksort( vector<int> & a, int left, int right )
127. {
128.     if( left + 10 <= right )
129.     {
130.         int pivot = median3( a, left, right );
132.             // Begin partitioning
133.         int i = left, j = right - 1;
134.         for( ; ; )
135.         {
136.             while( a[ ++i ] < pivot ) { }
137.             while( pivot < a[ --j ] ) { }
138.             if( i < j )
139.                 swap( a[ i ], a[ j ] );
140.             else
141.                 break;
142.         }
144.         swap( a[ i ], a[ right - 1 ] ); 
146.         quicksort( a, left, i - 1 );    
147.         quicksort( a, i + 1, right );    
148.     }
149.     else  
150.         insertionSort( a, left, right );
151. }
154. void quicksort( vector<int> & a )
155. {
156.     quicksort( a, 0, a.size( ) - 1 );
157. }