Binary lookup algorithm (recursive vs. non-recursive two ways)

First of all, the binary search method.

Binary search method is to find a set of ordered numbers, pass the corresponding data, compare to find the same data as the original data, find the return 1, failed to return the corresponding array subscript.

The two-point search method was completed by non-recursive method. The Java code is shown below.

[Java]View PlainCopyprint?

2. /* 
4. * Non-recursive binary search algorithm
6. * Parameter: integer array, the number to compare.
8. */
10. public static int BinarySearch (integer[]srcarray,int des) {
12. //First position.
14. int low=0;
16. //Highest position. Array Length-1, since the subscript is starting from 0.
18. int high=srcarray.length-1;
20. //When Low "pointer" and high do not repeat.
22. While (Low<=high) {
24. //Middle position calculation, low+ the highest position minus the lowest position, move right one bit, equivalent to 2. can also be used (High+low)/2
26. int middle=low+ ((high-low) >>1);
28. and//with the most intermediate numbers to determine whether they are equal or equal, the corresponding array subscripts are returned.
30. if (Des==srcarray[middle]) {
32. return middle;
34. //If less then move the "pointer" at the top level
36. }Else if (Des<srcarray[middle]) {
38. high=middle-1;
40. //Move the lowest "pointer"
42. }else{
44. Low=middle+1;
46. }
48. }
50. return-1;
52. }
56. }

Recursive method is used to complete the two-point search algorithm. The code is shown below.

[Java]View PlainCopy print?

2. /**
4. * Recursive method to realize the binary search method.
6. * @param array arrays
8. * @param low Array First position
10. * @param high
12. * @param key to find the value.
14. * @return return value.
16. */
18. int Binsearch (int array[],int low,int high,int key)
20. {
22. if (Low<=high)
24. {
26. int mid = (Low+high)/2;
28. if (key = = Array[mid])
30. return mid;
32. Else if (Key<array[mid])
34. //Move low and high
36. return Binsearch (array,low,mid-1,key);
38. Else if (Key>array[mid])
40. return Binsearch (array,mid+1,high,key);
42. }
44. Else
46. return-1;
48. }

Recursive thinking is often used, more prominent programming problem-solving efficiency.

Excerpt from: http://blog.csdn.net/lovesummerforever/article/details/24588989

Binary lookup algorithm (recursive vs. non-recursive two ways)