搜索算法总结

  1 #include <iostream>
  2 #include <bits/stdc++.h>
  3 
  4 #define MaxRandom 100                                // 随机数生成范围
  5 #define LengthOfWaitSort 20                            // 随机数生成个数
  6 
  7 using namespace std;
  8 
  9 
 10 /*******************************************************************/
 11 // 验证输出
 12 void printAfterSort(int* nums, int length)
 13 {
 14     for (int i = 0; i < length; ++i)
 15     {
 16         printf("%4d",nums[i]);
 17     }
 18     printf("\n");
 19 }
 20 /*******************************************************************/
 21 
 22 
 23 /*******************************************************************/
 24 // 快速排序
 25 void quick_sort(int* nums, int left, int right)
 26 {
 27     if (left < right)
 28     {
 29         int i = left;
 30         int j = right;
 31         int flag = nums[left];
 32 
 33         while (i < j)
 34         {
 35             while (i<j && nums[j]>=flag)            // 从右向左找第一个比基数小的元素
 36             {
 37                 j --;
 38             }
 39             if (i < j)
 40             {
 41                 nums[i++] = nums[j];
 42             }
 43 
 44             while (i<j && nums[i]<=flag)            // 从左向右找第一个比基数大的元素
 45             {
 46                 i ++;
 47             }
 48             if (i < j)
 49             {
 50                 nums[j--] = nums[i];
 51             }
 52         }
 53 
 54         nums[i] = flag;
 55         quick_sort( nums, left, i-1 );
 56         quick_sort( nums, i+1, right);
 57     }
 58 }
 59 
 60 void QuickSort(int* nums, int length)
 61 {
 62     int left  = 0;
 63     int right = length - 1;
 64     quick_sort(nums, left, right);
 65     // 输出
 66     printf("\nQuick Sort:\n");
 67     printAfterSort(nums, length);
 68 }
 69 /*******************************************************************/
 70 
 71 
 72 
 73 /*******************************************************************/
 74 // 顺序查找
 75 void Sequential_Search(int* nums, int length, int key)
 76 {
 77     printf("Sequential Search:\n");
 78     for (int i = 0; i < length; ++i)
 79     {
 80         if (nums[i] == key)
 81         {
 82             printf("Find %d in nums[%d]", key, i);
 83             return;
 84         }
 85     }
 86     printf("Not Find!\n");
 87 }
 88 /*******************************************************************/
 89 
 90 
 91 /*******************************************************************/
 92 // 哨兵顺序查找
 93 void Sequential_Search2(int* nums, int length, int key)
 94 {
 95     printf("Sequential Search2:\n");
 96     if (nums[0] == key)
 97     {
 98         printf("Find %d in nums[0]", key);
 99         return;
100     }
101     int temp = nums[0];
102     nums[0] = key;
103     int i = length;
104     while (nums[i] != key)
105     {
106         i --;
107     }
108     if (i == 0)
109     {
110         printf("Not Find!\n");
111         nums[0] = temp;
112     }
113     else
114     {
115         printf("Find %d in nums[%d]", key, i);
116         nums[0] = temp;
117         return;
118     }
119 }
120 /*******************************************************************/
121 
122 
123 /*******************************************************************/
124 // 二分查找(有序)
125 void Binary_Search(int* nums, int length, int key)
126 {
127     printf("Binary Search:\n");
128     int left, right, middle;
129     left  = 0;
130     right = length - 1;
131 
132     while (left <= right)
133     {
134         middle = (left + right) / 2;
135         if (key < nums[middle])
136         {
137             right = middle - 1;
138         }
139         else if (key > nums[middle])
140         {
141             left = middle + 1;
142         }
143         else
144         {
145             printf("Find %d in nums[%d]", key, middle);
146             return;
147         }
148     }
149     printf("Not Find!\n");
150 }
151 /*******************************************************************/
152 
153 
154 /*******************************************************************/
155 // 插值查找
156 void Insert_Search(int* nums, int length, int key)
157 {
158     printf("Insert Search:\n");
159     int left, right, middle;
160     left  = 0;
161     right = length - 1;
162 
163     while (left <= right)
164     {
165         middle = left + (right-left)*(key-nums[left])/(nums[right]-nums[left]);
166                                                     // 只在middle取值与二分不同
167         if (key < nums[middle])
168         {
169             right = middle - 1;
170         }
171         else if (key > nums[middle])
172         {
173             left = middle + 1;
174         }
175         else
176         {
177             printf("Find %d in nums[%d]", key, middle);
178             return;
179         }
180     }
181     printf("Not Find!\n");
182 }
183 /*******************************************************************/
184 
185 
186 /*******************************************************************/
187 // 斐波那契查找                                        // 未完成
188 void Fibonacci_Search(int* nums, int length, int key)
189 {
190     int left, right, middle;
191     int Fibonacci[100];                                // 斐波那契数列
192     left  = 0;
193     right = length - 1;
194 
195 
196 }
197 /*******************************************************************/
198 
199 
200 /*******************************************************************/
201 // 二叉排序树
202 typedef struct BitNode                                // 结点结构
203 {
204     int data;
205     struct BitNode *lchild;
206     struct BitNode *rchild;
207 } BitNode, *Bitree;
208 
209 int InOrderTraverse(Bitree T)                        // 中序遍历
210 {
211     if (T == NULL)
212     {
213 //        printf("Not Find!\n");
214         return 0;
215     }
216     InOrderTraverse(T->lchild);
217     printf("%4d ", T->data);
218     InOrderTraverse(T->rchild);
219     return 0;
220 }
221 
222 /*
223  * 递归查找二叉排序树T中是否存在key,
224  * 指针f指向T的双亲，其初始调用值为NULL
225  * 若查找成功，则指针p指向该数据元素结点，并返回1
226  * 否则指针p指向查找路径上访问的最后一个结点并返回0
227  */
228 int SearchBST(Bitree T, int key, Bitree f, Bitree *p)
229 {
230     if (!T)                                            // 不存在
231     {
232         *p = f;
233         return 0;
234     }
235     else if (key == T->data)                        // 查找成功
236     {
237         *p = T;
238         return 1;
239     }
240     else if (key < T->data)
241     {
242         return SearchBST(T->lchild, key, T, p);        // 在左子树继续查找
243     }
244     else
245     {
246         return SearchBST(T->rchild, key, T, p);        // 在右子树继续查找
247     }
248 }
249 
250 /*
251  * 二叉排序树中不存在key的时候,
252  * 插入key返回1，否则返回0
253  */
254 int InsertBST(Bitree *T, int key)
255 {
256     Bitree p, s;
257     if (!SearchBST(*T, key, NULL, &p))                // 没查到key
258     {
259         s = (Bitree)malloc(sizeof(BitNode));
260         s->data = key;
261         s->lchild = s->rchild = NULL;
262         if (!p)
263         {
264             *T = s;                                    // 插入s为新的根结点
265         }
266         else if (key < p->data)
267         {
268             p->lchild = s;                            // 插入s为p的左孩子
269         }
270         else
271         {
272             p->rchild = s;                            // 插入s为p的右孩子
273         }
274         return 1;
275     }
276     else
277         return 0;                                    // 原树中已有该节点
278 }
279 
280 /*
281  * 二叉排序树中删除p,
282  * 重接它的左/右子树
283  */
284 int Delete(Bitree *p)
285 {
286     Bitree q, s;
287     if ((*p)->rchild == NULL)                        // 右子树空则只需重接它的左子树（待删结点是叶子也走此分支)
288     {
289         q = *p;
290         *p = (*p)->lchild;
291         free(q);
292     }
293     else if ((*p)->lchild == NULL)                    // 只需重接它的右子树
294     {
295         q = *p;
296         *p = (*p)->rchild;
297         free(q);
298     }
299     else                                            // 左右子树均不为空
300     {
301         q = *p;
302         s = (*p)->lchild;                            // 向左一步再向右走到头
303         while (s->rchild)
304         {
305             q = s;
306             s = s->rchild;
307         }
308         (*p)->data = s->data;                        // s指向被删结点的直接前驱（将被删结点前驱的值取代被删结点的值）
309         if (q != *p)
310         {
311             q->rchild = s->lchild;                    // 重接q的右子树
312         }
313         else
314         {
315             q->lchild = s->lchild;                    // 重接q的左子树
316         }
317         free(s);
318     }
319     return 1;
320 }
321 
322 /*
323  * 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点,
324  * 否则返回0
325  */
326 int DeleteBST(Bitree *T, int key)
327 {
328     if (!*T)                                        // 不存在关键字等于key的数据元素
329     {
330         return 0;
331     }
332     else
333     {
334         if (key == (*T)->data)                        // 找到key
335         {
336             return Delete(T);
337         }
338         else if (key < (*T)->data)
339         {
340             return DeleteBST(&(*T)->lchild, key);
341         }
342         else
343         {
344             return DeleteBST(&(*T)->rchild, key);
345         }
346     }
347 }
348 
349 void BinarySortTree(int* nums, int length, int key)
350 {
351     printf("BinarySortTree:\n");
352     Bitree T = NULL;
353     for (int i = 0; i < length; ++i)
354     {
355         InsertBST(&T, nums[i]);
356     }
357     InOrderTraverse(T);
358     printf("\n");
359     printf("Delete %d:\n", nums[length/3*2]);
360     DeleteBST(&T, nums[length/3*2]);
361     InOrderTraverse(T);
362     printf("\n");
363     printf("SearchBST %d:\n", key);
364     Bitree p;
365     int ret = SearchBST(T, key, NULL, &p);
366     if (ret == 1)
367         printf("Find!\n");
368     else
369         printf("Not Find!\n");
370     return;
371 }
372 /*******************************************************************/
373 
374 
375 
376 int main()
377 {
378     clock_t start_time, finish_time;
379     double duration;
380     srand( (unsigned)time(NULL) );                  // 生成随机数种子
381     int length = LengthOfWaitSort;
382     int nums[length];
383     int temp[length];
384 
385     printf("Initial array:\n");
386     for (int i = 0; i < length; ++i)                // 输出随机数组nums
387     {
388         nums[i] = rand()%(MaxRandom-1);             // MaxRandom-1以内生成20个随机数
389         printf("%4d", nums[i]);
390     }
391 
392     memcpy(temp, nums, length*sizeof(int));         // temp为无序数组
393 
394     QuickSort(nums, length);                        // nums为有序数组
395 //    int key = 100000;
396     int key = nums[length / 3];
397     printf("key is %d\n\n", key);
398 
399     printf("Static Search:\n\n");
400     start_time = clock();
401     Sequential_Search(nums, length, key);            // 顺序查找
402     finish_time = clock();
403     duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
404     printf( "%f ms\n\n", duration );
405 
406     start_time = clock();
407     Sequential_Search2(nums, length, key);            // 哨兵顺序查找
408     finish_time = clock();
409     duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
410     printf( "%f ms\n\n", duration );
411 
412     start_time = clock();
413     Binary_Search(nums, length, key);                // 二分查找
414     finish_time = clock();
415     duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
416     printf( "%f ms\n\n", duration );
417 
418     start_time = clock();
419     Insert_Search(nums, length, key);                // 插值查找
420     finish_time = clock();
421     duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
422     printf( "%f ms\n\n", duration );
423 
424     printf("Dynamic Search:\n\n");
425     start_time = clock();
426     BinarySortTree(temp, length, key);                // 二叉排序树
427     finish_time = clock();
428     duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
429     printf( "%f ms\n\n", duration );
430 
431     return 0;
432 }