【数据结构】简单查找和排序

[cpp]  view plain copy print ?

1. /*********************************************** 
2. 【查找和排序】 几种常见的查找和排序算法 
3. ***********************************************/  
4. #include <iostream>  
5.   
6. // 顺序查找  
7. int squ_search(int array[],int count,int elem)  
8. {  
9.     for (int i=0;i<count;++i)  
10.     {  
11.         if (array[i] == elem)  
12.         {  
13.             return i;  
14.         }  
15.     }  
16.     return -1;  
17. }  
18.   
19. // 折半查找（array已经基本有序数据）  
20. int bin_search(int array[],int count,int elem)  
21. {  
22.     int low = 0;  
23.     int high = count -1;  
24.     int mid = count/2;  
25.   
26.     while(low <= high)  
27.     {  
28.         mid = (high+low)/2;  
29.         if (array[mid] == elem)  
30.         {  
31.             return mid;  
32.         }  
33.         else if (array[mid]>elem)  
34.         {  
35.             high = mid-1;  
36.         }  
37.         else  
38.         {  
39.             low = mid+1;  
40.         }  
41.     }  
42.     return -1;  
43. }  
44.   
45. //直接插入排序  小->大  
46. void insert_sort(int *array,int count)  
47. {  
48.     int i,j,tmp_elem;  
49.     for (int i=1;i<count;++i)  
50.     {  
51.         tmp_elem = array[i];  
52.         j = i-1;  
53.         while(j>0 && tmp_elem<array[j])  
54.         {  
55.             array[j+1] = array[j];  
56.             --j;  
57.         }  
58.     }  
59. }  
60.   
61. // 选择排序 小->大  
62. void select_sort(int *array,int count)  
63. {  
64.     int tmp_index;  
65.     for (int i=0;i<count;++i)  
66.     {  
67.         tmp_index = i;  
68.         for (int j=i+1;j<count;++j)  
69.         {  
70.             if (array[j]<array[tmp_index])  
71.             {  
72.                 tmp_index = j;  
73.             }  
74.         }  
75.         if (tmp_index != i)  
76.         {  
77.             int tmp_elem = array[i];  
78.             array[i] = array[tmp_index];  
79.             array[tmp_index] = tmp_elem;  
80.         }  
81.     }  
82. }  
83.   
84. // 冒泡排序 小->大  
85. void bubble_sort(int *array,int count)  
86. {  
87.     int tmp_elem;  
88.     for(int i=1;i<count;++i)  
89.     {  
90.         for (int j=0;j<=count-i;++j)  
91.         {  
92.             if(array[j]>array[j+1])  
93.             {  
94.                 tmp_elem = array[j];  
95.                 array[j] = array[j+1];  
96.                 array[j+1] = tmp_elem;    
97.             }  
98.         }  
99.     }  
100. }  
101.   
102. // 希尔排序 小->大  
103. void shell_sort(int *array,int count)  
104. {  
105.     int gap = count;  
106.     int j;  
107.     int tmp_elem;  
108.   
109.     while(gap>1)  
110.     {  
111.         gap = gap/2;  
112.   
113.         //bubble sort  
114.         for (int i=0;i<count-gap;++i)  
115.         {  
116.             j = i + gap;  
117.             if (array[j]>array[i])  
118.             {  
119.                 tmp_elem = array[i];  
120.                 array[i] = array[j];  
121.                 array[j] = tmp_elem;  
122.             }  
123.         }  
124.     }  
125. }  
126.   
127. // 快速排序 小->大  
128. void quick_sort(int *array,int s,int t)  
129. {  
130.     int i,j;  
131.     if (s<t)  
132.     {  
133.         i = s;  
134.         j = t +1;  
135.         while (true)  
136.         {  
137.             do   
138.             {  
139.                 ++i;  
140.             } while ( !(array[s]<=array[i] || i==t) );  
141.             do   
142.             {  
143.                 --j;  
144.             } while ( !(array[s]>=array[j] || j==s) );  
145.   
146.             if (i<j)  
147.             {  
148.                 int tmp_elem = array[i];  
149.                 array[i] = array[j];  
150.                 array[j] = tmp_elem;  
151.             }  
152.             else  
153.             {  
154.                 break;  
155.             }  
156.         }  
157.   
158.         int tmp_elem = array[s];  
159.         array[s] = array[j];  
160.         array[j] = tmp_elem;  
161.   
162.         quick_sort(array,s,j-1);  
163.         quick_sort(array,j+1,t);  
164.     }  
165.   
166. }