数据结构基础(2) --顺序查找 & 二分查找

顺序查找

适用范围:

没有进行排序的数据序列

缺点:

速度非常慢, 效率为O(N)

[cpp]  view plain  copy

 

1. //实现  
2. template <typename Type>  
3. Type *sequenceSearch(Type *begin, Type *end, const Type &searchValue)  
4. throw(std::range_error)  
5. {  
6.     if ((begin == end) || (begin == NULL) || (end == NULL))  
7.         throw std::range_error("pointer unavailable");  
8.   
9.     for (Type *index = begin; index < end; ++index)  
10.     {  
11.         if (*index == searchValue)  
12.             return index;  
13.     }  
14.   
15.     return end;  
16. }  
17.   
18. template <typename Type>  
19. Type *sequenceSearch(Type *array, int length, const Type &searchValue)  
20. throw(std::range_error)  
21. {  
22.     return sequenceSearch(array, array+length, searchValue);  
23. }  

迭代二分查找

应用范围:

数据必须首先排序,才能应用二分查找;效率为(logN)

算法思想:

譬如数组{1， 2， 3， 4， 5， 6， 7， 8， 9}，查找元素6，用二分查找的算法执行的话，其顺序为：

    1.第一步查找中间元素，即5，由于5<6，则6必然在5之后的数组元素中，那么就在{6， 7， 8， 9}中查找，

    2.寻找{6， 7， 8， 9}的中位数，为7，7>6，则6应该在7左边的数组元素中，那么只剩下6，即找到了。

    二分查找算法就是不断将数组进行对半分割，每次拿中间元素和目标元素进行比较。

[cpp]  view plain  copy

 

1. //实现:迭代二分  
2. template <typename Type>  
3. Type *binarySearch(Type *begin, Type *end, const Type &searchValue)  
4. throw(std::range_error)  
5. {  
6.     if ((begin == end) || (begin == NULL) || (end == NULL))  
7.         throw std::range_error("pointer unavailable");  
8.   
9.     /**注意:此处high为end-1,并不是end 
10.         因为在后续的查找过程中,可能会如下操作 (*high), 或等价的操作 
11.         此时应该访问的是最后一个元素, 必须注意不能对数组进行越界访问! 
12.     */  
13.     Type *low = begin, *high = end-1;  
14.     while (low <= high)  
15.     {  
16.         //计算中间元素  
17.         Type *mid = low + (high-low)/2;  
18.         //如果中间元素的值==要找的数值, 则直接返回  
19.         if (*mid == searchValue)  
20.             return mid;  
21.         //如果要找的数比中间元素大, 则在数组的后半部分查找  
22.         else if (searchValue > *mid)  
23.             low = mid + 1;  
24.         //如果要找的数比中间元素小, 则在数组的前半部分查找  
25.         else  
26.             high = mid - 1;  
27.     }  
28.   
29.     return end;  
30. }  
31.   
32. template <typename Type>  
33. Type *binarySearch(Type *array, int length, const Type &searchValue)  
34. throw(std::range_error)  
35. {  
36.     return binarySearch(array, array+length, searchValue);  
37. }  

递归简介

递归就是递归...(自己调用自己),递归的是神,迭代的是人;

 

递归与非递归的比较

[cpp]  view plain  copy

 

1. //递归求解斐波那契数列  
2. unsigned long ficonacciRecursion(int n)  
3. {  
4.     if (n == 1 || n == 2)  
5.         return 1;  
6.     else  
7.         return ficonacciRecursion(n-1) + ficonacciRecursion(n-2);  
8. }  

[cpp]  view plain  copy

 

1. //非递归求解斐波那契数列  
2. unsigned long ficonacciLoop(int n)  
3. {  
4.     if (n == 1 || n == 2)  
5.         return 1;  
6.   
7.     unsigned long  first = 1, second = 1;  
8.     unsigned long  ans = first + second;  
9.     for (int i = 3; i <= n; ++i)  
10.     {  
11.         ans = first + second;  
12.         first = second;  
13.         second = ans;  
14.     }  
15.   
16.     return ans;  
17. }  

递归二分查找

算法思想如同迭代二分查找;

[cpp]  view plain  copy

 

1. //实现  
2. template <typename Type>  
3. Type *binarySearchByRecursion(Type *front, Type *last, const Type &searchValue)  
4. throw(std::range_error)  
5. {  
6.     if ((front == NULL) || (last == NULL))  
7.         throw std::range_error("pointer unavailable");  
8.   
9.     if (front <= last)  
10.     {  
11.         Type *mid = front + (last-front)/2;  
12.         if (*mid == searchValue)  
13.             return mid;  
14.         else if (searchValue > *mid)  
15.             return binarySearchByRecursion(mid+1, last, searchValue);  
16.         else  
17.             return binarySearchByRecursion(front, mid-1, searchValue);  
18.     }  
19.   
20.     return NULL;  
21. }  
22.   
23. template <typename Type>  
24. int binarySearchByRecursion(Type *array, int left, int right, const Type &searchValue)  
25. throw (std::range_error)  
26. {  
27.     if (array == NULL)  
28.         throw std::range_error("pointer unavailable");  
29.   
30.     if (left <= right)  
31.     {  
32.         int mid = left + (right-left)/2;  
33.         if (array[mid] == searchValue)  
34.             return mid;  
35.         else if (searchValue < array[mid])  
36.             return binarySearchByRecursion(array, left, mid-1, searchValue);  
37.         else  
38.             return binarySearchByRecursion(array, mid+1, right, searchValue);  
39.     }  
40.   
41.     return -1;  
42. }  

小结:

其实C++ 的STL已经实现好了std::binary_search(),在用的时候我们只需调用即可, 但是二分算法的思想还是非常重要的, 在求解一些较为复杂的问题时, 我们时常能够看到二分的身影.