各种排序算法C++实现

1. //各种排序算法的实现
   
2. /*
   
3. 交换函数
   
4. */
   
5. void swap(int *list, int low, int high )
   
6. {    
   
7.     int temp = list[low];
   
8.     list[low] = list[high];
   
9.     list[high] = temp;
   
10. }
    
11. 
    
12. /*
    
13. 小于函数
    
14. */
    
15. bool lt(const int low, const int high )
    
16. {
    
17.     if(low < high)
    
18.         return true;
    
19.     else
    
20.         return false;
    
21. }
    
22. 
    
23. /*
    
24. 插入排序（稳定）
    
25. 原理：插入排序逐个处理待排序的记录。每个新记录与前面已排序的子序列进行比较，
    
26. 将它插入到子序列中正确的位置
    
27. 代价是n2
    
28. */
    
29. void inssort( int *list, int n )
    
30. {
    
31.     int i,j;
    
32.     for( i = 1; i < n; i++ )
    
33.     {
    
34.         for( j = i; ( j > 0 ) && ( lt( list[j], list[j-1] ) ); j-- )
    
35.             swap( list, j, j-1 );
    
36.     }
    
37. }
    
38. 
    
39. /*
    
40. 冒泡排序（稳定）
    
41. 原理：第一次的内部for循环从记录数组的底部比较到顶部，比较相邻的值。
    
42. 如果低序号的值比高序号的值大，则二者交换顺序
    
43. 代价是n2
    
44. */
    
45. void bubsort( int *list, int n )
    
46. {
    
47.     int i,j;
    
48.     for ( i = 0; i < n-1; i++ )
    
49.     {
    
50.         for ( j = n-1; j > i; j-- )
    
51.         {    
    
52.             if( lt( list[j], list[j-1] ) )
    
53.                 swap( list, j, j-1 );
    
54.         }
    
55.     }
    
56. }
    
57. 
    
58. /*
    
59. 选择排序（不稳定）
    
60. 原理：选择排序的第i次是“选择”数组中第i小的记录，并将该记录放到数组的第i个位置。
    
61. 即首先从未排序的序列中找到最小的值，接着找到次小的，依次类推
    
62. 代价是n2
    
63. */
    
64. void selsort( int *list, int n )
    
65. {
    
66.     int i,j;
    
67.     for ( i = 0; i < n-1; i++ )
    
68.     {
    
69.         int low_index = i;
    
70.         for ( j = n-1; j > i; j-- )
    
71.         {    
    
72.             if( lt( list[j], list[low_index] ) )
    
73.                 low_index = j;
    
74.         }
    
75.         swap( list, i, low_index );
    
76.     }
    
77. }
    
78. 
    
79. /*
    
80. 插入排序函数（shell排序的辅助函数）
    
81. */
    
82. void inssort( int *list, int n, int incr )
    
83. {
    
84.     int i,j;
    
85.     for ( i = incr; i < n; i += incr )
    
86.     {
    
87.         for ( j = i; (j >= incr) && (lt (list[j],list[j-incr]) ); j -= incr )
    
88.         {    
    
89.             swap( list, j, j-incr );
    
90.         }        
    
91.     }
    
92. }
    
93. 
    
94. /*
    
95. shell排序（不稳定）
    
96. 原理：将序列分成子序列，然后分别对子序列用插入排序的方法进行排序，最后将子序列组合起来。
    
97. 代价是n1.5
    
98. */
    
99. void shellsort( int *list, int n )
    
100. {
     
101.     int i,j;
     
102.     for ( i = n/2; i > 2; i /= 2 )
     
103.     {
     
104.         for ( j = 0; j < i; j++ )
     
105.         {    
     
106.             inssort(&list[j], n-j, i);
     
107.         }
     
108.     }
     
109.     inssort(list, n, 1);
     
110. }
     
111. 
     
112. /*
     
113. 快速排序(不稳定)
     
114. 原理：首先选择一个轴值，小于轴值的结点被放到轴值的左边，大于轴值的结点被放到轴值的右边，这样轴值就被放在了正确的位置上。
     
115. 然后对轴值左边和右边的子序列进行类似操作。
     
116. 第一次调用的形式为quicksort(list,0,n-1)
     
117. 代价是n*logn
     
118. */
     
119. void quicksort(int *list, int low, int high)
     
120. {
     
121.     int pivot = list[ (low + high) / 2 ];
     
122.     int left = low - 1;
     
123.     int right = high;
     
124.     
     
125.     if(low >= high)
     
126.         return 0;
     
127.     
     
128.     swap(list, (low + high) / 2, high);          
     
129.     do     
     
130.     {
     
131.         while(list[++left] < pivot);         
     
132.         while(right != 0 && list[--right] > pivot);         
     
133.         swap(list, left, right);     
     
134.     } while (left < right);          
     
135.     
     
136.     swap(list, left, right);     
     
137.     swap(list, left, high);          
     
138.     
     
139.     quicksort(list, low, left - 1);     
     
140.     quicksort(list, left + 1, high);
     
141. }