Algorithm of _001_ binary search algorithm

Binary search algorithm is one of the more frequent algorithms used in ordered arrays, in the non-contact binary lookup algorithm, the most common approach is to traverse the array, compare each element, and its time is O (n). But the binary lookup algorithm is better because it has a lookup time of O (LGN), such as the array {1, 2, 3, 4, 5, 6, 7, 8, 9}, find element 6, executed with binary lookup algorithm, in the order of:

1. The first step is to find the intermediate element, that is, 5, because 5<6, 6 is necessarily in the array element after 5, then it is found in {6, 7, 8, 9},
2. Looking for the median of {6, 7, 8, 9}, which is 7,7>6, 6 should be in the array element to the left of 7, then only 6 is found.

The binary search algorithm is to continuously divide the array into half, and compare the intermediate elements with goal each time.

Realization of--java code with binary search method

1, premise: The premise of binary search is to find the array must be sorted, our implementation here is the default ascending

2, principle: The array is divided into three parts, in order is the median (the so-called median is the middle of the array value) before, median, median value, the value to be looked up and the median of the array to compare, if less than the median value is in front of the median value is found, if the value is greater than the median value after the Then there is a recursive procedure, in which the first half or the second part continues to be decomposed into three parts. may not be described very clearly, if you do not understand can go online to find. It can be seen from the description that this algorithm is suitable for recursive implementation, can be used recursively can be used to achieve the loop. So our implementation is divided into recursive and cyclic two, can be based on the code to understand the algorithm

3, implementation: code as follows

[Java]View PlainCopy

2. Package org.cyxl.algorithm.search;
6. /**
8. * Two-point search
10. * @author CYXL
12. *
14. */
16. Public class BinarySearch {
18. private int rcount=0;
20. private int lcount=0;
24. /** 
26. * Number of times to get recursion
28. * @return
30. */
32. public int Getrcount () {
34. return rcount;
36. }
40. /** 
42. * Number of times to get loops
44. * @return
46. */
48. public int Getlcount () {
50. return lCount;
52. }
56. /** 
58. * Performs a recursive binary lookup, returning the position where the value first appears
60. * @param sorteddata sorted array
62. * @param start position
64. * @param End Position
66. * @param findvalue need to find the value
68. * @return The position of the value in the array, starting at 0. No return-1 found
70. */
72. public int searchrecursive (int[] sorteddata,int start,int end,int findvalue) /c4>
74. {
76. rcount++;
78. if (start<=end)
80. {
82. //Middle position
84. int middle= (start+end) >>1; //equivalent (Start+end)/2
86. //Middle value
88. int Middlevalue=sorteddata[middle];
92. if (findvalue==middlevalue)
94. {
96. //equals median return directly
98. return middle;
100. }
102. Else if (findvalue<middlevalue)
104. {
106. //Less than mid value when looking in front of the median value
108. return searchrecursive (sorteddata,start,middle-1,findvalue);
110. }
112. Else
114. {
116. //greater than median is found after median value
118. return searchrecursive (sorteddata,middle+1,end,findvalue);
120. }
122. }
124. Else
126. {
128. //Not found
130. return-1;
132. }
134. }
138. /** 
140. * Loop binary lookup, returns the position of the first occurrence of the value
142. * @param sorteddata sorted array
144. * @param findvalue need to find the value
146. * @return The position of the value in the array, starting at 0. No return-1 found
148. */
150. public int Searchloop (int[] sorteddata,int findvalue)
152. {
154. int start=0;
156. int end=sorteddata.length-1;
160. While (start<=end)
162. {
164. lcount++;
166. //Middle position
168. int middle= (start+end) >>1; //equivalent (Start+end)/2
170. //Middle value
172. int Middlevalue=sorteddata[middle];
176. if (findvalue==middlevalue)
178. {
180. //equals median return directly
182. return middle;
184. }
186. Else if (findvalue<middlevalue)
188. {
190. //Less than mid value when looking in front of the median value
192. end=middle-1;
194. }
196. Else
198. {
200. //greater than median is found after median value
202. Start=middle+1;
204. }
206. }
208. //Not found
210. return-1;
212. }
214. }

4. Test code

[Java]View PlainCopy

2. Package org.cyxl.algorithm.search.test;
6. Import Org.cyxl.algorithm.search.BinarySearch;
8. Import Org.junit.Test;
14. Public class Binarysearchtest {
16. @Test
18. public void Testsearch ()
20. {
22. BinarySearch bs=New BinarySearch ();
26. int[] sorteddata={1,2,3,4,5,6,6,7,8,8,9,10};
28. int findvalue=9;
30. int length=sorteddata.length;
34. int pos=bs.searchrecursive (Sorteddata, 0, length-1, findvalue);
36. System.out.println ("Recursice:" +findvalue+"found in pos" +pos+"; Count:" +bs.getrcount ());
38. int Pos2=bs.searchloop (sorteddata, findvalue);
42. System.out.println ("Loop:" +findvalue+"found in pos" +pos+"; Count:" +bs.getlcount ());
44. }
46. }

5, Summary: This way of finding the use of the situation is a sorted array. You can see that recursion and looping are the same number of times.

Algorithm of _001_ binary search algorithm