算法-排序递归（Algorithm - sort recursion）.doc

算法-排序递归（Algorithm - sort recursion） 1. Linear search Start with the first element of the array and compare it to the lookup value, and if the equality stops, then go ahead and find the match value until you find the match. Note: the elements in the array that are being searched are unordered and random. For example, linear-lookup code for an integer array: Static Boolean linear search (int target, int [] array) { / / traverse the entire array and compare each traversal element to the lookup value For (int I = 0; I array.length; I + +) { If (array [I] = = target) { Return true; } } Return false; } Three conditions of the algorithm are analyzed: A. Best case The value to find is in the first position of the array. In other words, you can achieve the purpose only once, so the big O expression of the best case is: O (1). B. Worst case scenario If the value to be found is at the end of the array or not, then an array of size n must be compared n times. The big O expression is: O (n). C. Average situation Estimates will perform: (n + (n - 1) + (n - 2) +.... + 1)/n = (n + 1) / 2 times, complexity of O (n) 2. Binary search Hypothesis was to find the elements in the array is ascending, then we find value, the first directly to the intermediate position of the array (array length / 2), and the median and find value comparison, if equal return, otherwise, if the current element value is less than finding, half continues in the back of the array to find (repeat the above process); If the current element value is greater than the lookup value, you will continue to search the first half of the array until you find the target value or stop when the binary array is not available. Note: binary search is just an array or collection of ordered arrays Code: Static Boolean binarySearch (int target, int [] array) { Int front = 0; Int tail = array.length - 1; / / whether the subarray can be divided again While (front = tail) { / / get the middle position of the subarray, and then make a