冒泡，插入，折半插入，希尔，快速，简单选择排序的源代码总结

转自：http://blog.csdn.net/rhljiayou/article/details/7824110

1. #include <iostream>  
2. using namespace std;  
3. //各种排序方法：  
4. /**冒泡排序法**/  
5. //它的时间复杂度为O（n^2），虽然不及堆排序、快速排序的O（nlogn，底数为2），但是有两个优点：1.“编程复杂度”很低，很容易写出代码；2.具有稳定性，这里的稳定性是指原序列中相同元素的相对顺序仍然保持到排序后的序列，而堆排序、快速排序均不具有稳定性。  
6. void Bubble_sort(int s[],int len){  
7.     int i,j,flag;  
8.     for (i=len-1; i>=1; i--) {  
9.         flag=1;  
10.         for (j=i-1; j>=0; j--) {  
11.             if (s[i]<s[j]) {  
12.                 swap(s[i], s[j]);  
13.                 flag=0;  
14.             }  
15.         }  
16.         if (1==flag) {//表示已经排序完成  
17.             break;  
18.         }  
19.     }  
20. }  
21. /**插入排序法**/  
22. //插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。  
23. void Insert_sort(int s[],int len){   
24.     int i,j;  
25.     int temp;  
26.     for(i=1;i<len;i++){  
27.         temp=s[i];  
28.         for (j=i; j>0&&temp<s[j-1]; j--) {  
29.             s[j]=s[j-1];  
30.         }  
31.         s[j]=temp;  
32.     }  
33. }  
34. /**折半插入排序法**/  
35. //当第i个元素要进行排序的时候，它前面的1到i-1位置上的数据是局部有序的，对于有序的数据序列，采用折半查找法去判断在何处插入i位置上的数据，就大大减少了需要比较的次数。  
36. void HalfInsert_sort(int s[], int len){  
37.     int temp, low, high, i, j, mid;  
38.     for (i=1; i<len; ++i)  
39.     {  
40.         temp = s[i];  
41.         low = 0;  
42.         high = i - 1;  
43.           
44.         while (high >= low)  
45.         {  
46.             mid = (low + high) / 2;  
47.               
48.             if (temp < s[mid])  
49.             {  
50.                 high = mid - 1;  
51.             }  
52.               
53.             else  
54.             {  
55.                 low = mid + 1;  
56.             }  
57.         }  
58.           
59.         for (j=i-1; j>=low; --j)  
60.         {  
61.             s[j+1] = s[j];  
62.         }  
63.           
64.         s[low] = temp;  
65.     }  
66. }  
67.   
68. /**希尔排序法**/  
69. //希尔排序法(缩小增量法) 属于插入类排序，是将整个无序列分割成若干小的子序列分别进行插入排序的方法。  
70. void Hill_sort(int s[],int len){  
71.     int h,j,k,t;  
72.     for (h=len/2; h>0; h=h/2) {//控制增量  
73.         for (j=h;j<len; j++) {  
74.             t=s[j];  
75.             for (k=j-h; k>=0&&t<s[k]; k-=h) {  
76.                 s[k+h]=s[k];  
77.             }  
78.             s[k+h]=t;  
79.         }  
80.     }  
81. }  
82.   
83. /**快速排序法**/  
84. //快速排序（Quicksort）是对冒泡排序的一种改进。通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。  
85. //挖坑法  
86. void quick_sort1(int s[],int l, int r){  
87.     int i=l;  
88.     int j=r;  
89.     int x=s[i];//第一个坑  
90.     if(i>=j) return ;  
91.     while (i!=j) {  
92.         //从右向左找小于x的数来填s[i];  
93.         while (i<j&&s[j]>=x) {  
94.             j--;  
95.         }  
96.         s[i]=s[j];  
97.         //从左向右找大于或等于x的数来填s[j];  
98.         while (i<j&&s[i]<x) {  
99.             i++;  
100.         }  
101.         s[j]=s[i];  
102.     }  
103.     s[i]=x;  
104.     quick_sort1(s, l, i-1);  
105.     quick_sort1(s, i+1, j);   
106. }  
107. /**简单选择排序法**/  
108. //选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾(目前已被排序的序列)。以此类推，直到所有元素均排序完毕。  
109. void Select_sort(int s[], int len){  
110.     int i,j,min;  
111.     for (i=0; i<len-1; i++) {  
112.         min=i;  
113.         for (j=i+1; j<len; j++) {  
114.             if (s[min]>s[j]) {  
115.                 min=j;//把值最小的下标记下来  
116.             }  
117.         }  
118.         if (min!=i) {  
119.             swap(s[i], s[min]);  
120.         }  
121.     }  
122. }  
123.   
124. //输出  
125. void prain(int s[],int len){  
126.     for (int i=0; i<len; i++) {  
127.         cout<<s[i]<<" ";  
128.     }  
129.     cout<<endl;  
130. }  
131. int main(int argc, const char * argv[])  
132. {  
133.   
134.     //从小到大排序  
135.     int s[]={10,1,4,2,3,8,7,6,5,9};  
136.     int len=sizeof(s)/sizeof(int);  
137.     /**起泡排序法**/  
138.     Bubble_sort(s,len);  
139.     cout<<"冒泡法：";  
140.     prain(s, len);  
141.     cout<<endl;  
142.       
143.     /**插入排序法**/  
144.     int s1[]={10,1,4,2,3,8,7,6,5,9};  
145.     int len1=sizeof(s1)/sizeof(int);  
146.     Insert_sort(s1,len1);  
147.     cout<<"插入法：";  
148.     prain(s1, len1);  
149.     cout<<endl;  
150.       
151.     /**希尔排序法**/  
152.     int s2[]={10,1,4,2,3,8,7,6,5,9};  
153.     int len2=sizeof(s)/sizeof(int);  
154.     Hill_sort(s2,len2);  
155.     cout<<"希尔排序法：";  
156.     prain(s2, len2);  
157.     cout<<endl;  
158.       
159.     /**快速排序法**/  
160.     int s3[]={10,1,4,2,3,8,7,6,5,9};  
161.     int len3=sizeof(s)/sizeof(int);  
162.     Insert_sort(s3,len3);  
163.       
164.     /**简单选择排序法**/  
165.     int s4[]={10,1,4,2,3,8,7,6,5,9};  
166.     int len4=sizeof(s)/sizeof(int);  
167.     Select_sort(s4,len4);  
168.     cout<<"简单选择排序法：";  
169.     prain(s4, len4);  
170.     cout<<endl;  
171.       
172.     /**折半插入排序法**/  
173.     int s5[]={10,1,4,2,3,8,7,6,5,9};  
174.     int len5=sizeof(s)/sizeof(int);  
175.     HalfInsert_sort(s5,len5);  
176.     cout<<"折半插入法：";  
177.     prain(s5, len5);  
178.     cout<<endl;  
179.       
180.     return 0;  
181. }