# Recursive binary search program in cpp

A binary search divides a range of values into halves, and continues to narrow down the field of search until the unknown value is found.

It is the recursive binary search program in cpp example of a "divide and conquer" algorithm. As an analogy, consider the children's game " guess a number. The player then uses this information to guess a new number. As the player, an optimal strategy for the general case is to start by choosing the range's midpoint as the guess, and then asking whether the guess was higher, lower, or equal to the secret number. If the guess was too high, one would select the point exactly between the range midpoint and the beginning of the range.

If the original guess was too low, one would ask about the point exactly between the range midpoint and the end of the range. This process repeats until one has reached the secret number. Given the starting point of a range, the ending point of a range, and the "secret value", implement a binary search through a sorted integer array for a certain number. Implementations can be recursive or iterative both if you can. Print out whether or not the number was in the array afterwards. If it was, print the index also.

There are several binary search algorithms commonly seen. They differ by how they treat multiple values equal to the given value, and whether they indicate whether the element was found or not.

For completeness we will present pseudocode for all of them. All of the following code examples use an "inclusive" upper bound i. Any of the examples can be converted into an equivalent example using "exclusive" upper bound i.

The algorithms are as follows from Wikipedia. The algorithms return the index of some element that equals the given value if there are multiple such elements, it returns some arbitrary one. It is also possible, when the element is not found, to return the "insertion point" for it the index that the value would have if it were inserted into the array.

The following algorithms return the leftmost place where the given element can be correctly inserted and still maintain the sorted order. This is the lower inclusive bound of recursive binary search program in cpp range of elements that are equal to the given value if any. Equivalently, this is the lowest index where the element is greater than or equal to the given value since if it were any lower, it would violate the orderingor 1 past the last index if such an element does not exist.

This algorithm does not determine if the element is actually found. This algorithm only requires one comparison per level. The following algorithms return the rightmost place where the given element can be correctly inserted and still maintain the sorted order. This is the upper exclusive bound of the range of elements that are equal to recursive binary search program in cpp given value if any.

Equivalently, this is the lowest index where the element is greater than the given value, or 1 past the last index if such an element does not exist.

Note that these algorithms are almost exactly the same as the leftmost-insertion-point algorithms, except for how the inequality treats equal values. This can occur if the array size is greater than half the maximum integer value. Indexing an array with a negative number could produce an out-of-bounds exception, or other undefined behavior.

If unsigned integers are used, an overflow will result in losing the largest bit, which will produce the wrong result. The reason why this works is that, for signed integers, even though it overflows, when viewed as an unsigned number, the value is still the correct sum.

To divide an unsigned number by 2, simply do a logical right shift. Both solutions are generic. Note that the completion condition is different from one given in the pseudocode example above. The example assumes that the array index type does not overflow when mid is incremented or decremented beyond the corresponding array bound. This is a recursive binary search program in cpp assumption for Ada, where array bounds can start or end at the very first or last value of the index type.

To deal with this, the exit condition is rather directly expressed as crossing the corresponding array bound by the coming interval middle. Note that the difference between the bounds is the number of elements equal to the element you want. It does not give you any information as to where it is. The following solution is based on the one described in: Recursive binary search program in cpp, Classification, and Examples.

Also available at http: It includes detailed loop invariants and pre- and postconditions, which make the running time linear instead of logarithmic recursive binary search program in cpp full contract checking is enabled.

User-defined implementations of the same would be considerably slower. Nonetheless, here they are in order to comply with the task requirements.

Factor already includes a binary search in its standard library. The following code offers an interface compatible with the requirement of this task, and returns either the index of the element if it has been found or f otherwise. This version is designed for maintaining a sorted array. If the item is not found, then then location returned is the proper insertion point for the item.

This could be used in an optimized Insertion sortfor example. This has the array indexed from 1 to N, and the "not found" return code is zero or negative. Changing the search to be for A first: For the more advanced fortrans, declaring the parameters to be INTENT IN may help, as despite passing arrays "by reference" being the norm, the newer compilers may generate copy-in, copy-out code, vitiating the whole point of using a fast binary search instead of a slow linear search.

In such a situation however, preparing in-line code may be the better move: Later compilers offer features allowing the development of "generic" functions so that the same function name may be used yet the actual routine invoked will be selected according to how the parameters are integers or floating-point, and of different precisions. There would still need to be a version of the function for each type combination, each with its own name.

Unfortunately, there is no three-way comparison test for character data. The use of "exclusive" bounds simplifies the adjustment of the bounds: The "inclusive" bounds version by contrast requires two manipulations of Recursive binary search program in cpp and R at recursive binary search program in cpp step - once to see if the span is empty, and a second time to locate the index to test. Imagine a test array containing the even numbers: A count could be kept of the number of probes required to find each of those four values, and likewise with a search for the odd numbers 1,3,5,7,9 that would probe all the places where a value might be not found.

Plot the average number of probes for the two cases, plus the maximum number of probes for any case, and then repeat for another number of elements to search. With only one element in the array to be searched, all values are the same: The point of this is recursive binary search program in cpp the IF-test is going to initiate some jumps, so why not arrange that one of the bound adjustments needs no subsequent jump to the start of the next iteration - in the first version, both bound adjustments needed such a jump, the GO TO 1 statements.

This was done by shifting recursive binary search program in cpp code for label 2 up recursive binary search program in cpp precede the code for label 1 - and removing its now pointless GO TO 1 executed each timebut adding an initial GO TO 1, executed once only.

This sort of change is routine when manipulating spaghetti code It is because the method involves such a small amount of effort per iteration that minor changes offer a significant benefit.

A lot depends on the implementation of the three-way test: These branch tests may in turn be made in an order that notes which option if any involves "falling through" to the next statement, thus it may be better to swap the order of labels 3 and 4.

Further, the compiler may itself choose to re-order the various code pieces. An assembler version of this routine attended to all these details. Some compilers do not produce machine code directly, but instead translate the source code into another language which is then compiled, and a common choice for that is C.

This is all very well, but C is one of the many languages that do not have a three-way test option and so cannot represent Fortran's three-way IF statement **recursive binary search program in cpp.** Before emitting asservations of faith that pseudocode such as. That is, does the compiler make any remark, and does the resulting machine code contain a redundant test?

However, despite all the above, the three-way IF statement has been declared deprecated in later versions of Fortran, with no alternative to repeated testing offered. Incidentally, the exclusive-bounds version leads to a good version of the interpolation search whereby the probe position is interpolated, not just in the middle of the spanunlike the version based on inclusive-bounds.

Further, the unsourced offering in Wikipedia contains recursive binary search program in cpp bug - try searching an array of two equal elements for that value. There are also functions sort. SearchStringsand a very general sort.

Search function that allows you to binary search a range of numbers based on any condition not necessarily just search for an index of an element in an array. The algorithm itself, parametrized by an "interrogation" predicate p in the spirit of the explanation above:.

The algorithm uses tail recursion, so the iterative and the recursive approach are identical in Haskell the compiler will convert recursive calls into jumps. J already includes a binary search primitive I. The following **recursive binary search program in cpp** offers an interface compatible with the requirement of this task, and returns either the index of the element if it has been found or 'Not Found' otherwise:.

If the input array is sorted, then binarySearch value as defined here will return an index i. Can be tested in http: The calculation of "mid" cannot overflow, since Maple uses arbitrary precision integer arithmetic, and the largest list or array is far, far smaller than the effective range of integers.

The following is another implementation that takes a more manual approach. Instead of using an intrinsic function, a general binary search algorithm is implemented using the language alone.

Returns a positive index if found, otherwise the negative index where it would go if inserted now. Incidentally, REXX doesn't care if the values are integers or even numbersas long as they're in order. The calls to helper are in tail position, so since Scheme implementations support proper tail-recursion the computation proces is iterative.

SPARK does not allow recursion, so only the iterative solution is provided. This example shows the use of a loop assertion. Search is a procedure, rather than a function, so that it can return a Found flag and a Position for Item, if found.

This is better design than having a Position value that means 'item recursive binary search program in cpp found'.

In computer sciencebinary searchalso known as half-interval search[1] logarithmic search[2] or binary chop[3] is a search algorithm that finds the position of a target value within a sorted recursive binary search program in cpp.

If the search ends with the remaining half being empty, the target is not in the array. Binary search runs in at worst logarithmic timemaking O log n comparisons, where n is the number of elements in the array, the O is Big O notationand log is the logarithm.

Binary search takes constant O 1 space, meaning that the space **recursive binary search program in cpp** by the algorithm is the same for any number of elements in the array. Although the idea is simple, implementing binary search correctly requires attention to some subtleties about its exit conditions and midpoint calculation.

There are numerous variations of binary search. In particular, fractional cascading speeds up binary searches for the same value in multiple arrays, efficiently solving a series of search problems in computational geometry and numerous other fields. Exponential search extends binary search recursive binary search program in cpp unbounded lists. The binary search tree and B-tree data structures are based on binary search.

Binary search works on sorted recursive binary search program in cpp. Binary search begins by comparing the middle element of the array with the target value. If the target value matches the middle element, its position in the array is returned. If the target value is less than or greater than the middle element, the search continues in the lower or upper half of the array, respectively, eliminating the other half from consideration.

Given an array A of n elements with values or records A 0A 1In the above procedure, the algorithm checks whether the middle element m is equal to the target t in every iteration. Some implementations leave out this check during each iteration. This results in a faster comparison loop, as one comparison is eliminated per iteration. However, it requires one more iteration on average.

The above procedure only performs exact matches, finding the position of a target value. However, due to the ordered nature of sorted arrays, it is trivial to extend binary search to perform approximate matches.

For example, binary search can be used to compute, for a given value, its rank the number of smaller elementspredecessor next-smallest elementsuccessor next-largest elementand nearest neighbor. Range queries seeking the number of elements between two values can be performed with two rank queries.

The performance of binary search can be analyzed by reducing the procedure to a binary comparison tree, where the root node is the middle element of the array. The middle element of the lower half is the left child node of the root recursive binary search program in cpp the middle element of the upper half is the right child node of the root.

The rest of the tree is built in a similar fashion. This model represents binary search; starting from the root node, the left or right subtrees are traversed depending on whether the target value is less or more than the node under consideration, representing the successive elimination of elements.

The worst case is reached when the search reaches the deepest level of the tree, equivalent to a binary search that has reduced to one element and, in each iteration, always eliminates the smaller subarray out of the two if they are not of equal size.

The worst case may recursive binary search program in cpp be reached when the target element is not in the array. In the best case, where the target value is the middle element of the array, its position is returned after one iteration. In terms of iterations, no search algorithm that works only by comparing elements can exhibit better average and worst-case performance than binary search. This is because the comparison tree representing binary search has the fewest levels possible as each level is filled completely with nodes if there are enough.

This is the case for other recursive binary search program in cpp algorithms based on comparisons, as while they may work faster on some target values, the average performance over all elements is affected.

This problem is solved by binary search, as dividing the array in half ensures that the size of both subarrays are as similar as possible. Fractional cascading can be used to speed up searches of the same value in multiple arrays.

Each iteration of the binary search procedure defined above makes one or two comparisons, checking if the middle element is equal to the target in each iteration. Again assuming that each element is equally likely to be searched, each iteration makes 1. A variation of the algorithm checks whether the middle element is equal to the target at the end of the search, **recursive binary search program in cpp** on average half a comparison from each iteration. This slightly cuts the time taken per iteration on most computers, while **recursive binary search program in cpp** that the search takes the maximum number of iterations, on average adding one iteration to the search.

For implementing associative arrayshash tablesa data structure that maps keys recursive binary search program in cpp records using a hash functionare generally faster than binary search on a sorted array of records; [19] most implementations require only amortized constant time on average.

In addition, all operations possible on a sorted array can be performed—such as finding the smallest and largest key and performing range searches. A binary search tree is a binary tree data structure that works based on the principle of binary search. The records of the tree are arranged in sorted order, and each record in the tree can be searched using an algorithm similar to binary search, taking on average logarithmic time.

Insertion and deletion also require on average logarithmic time in binary search trees. This can be faster than the linear time insertion recursive binary search program in cpp deletion of sorted arrays, and binary trees retain the ability to perform all the operations possible on a sorted array, including range and approximate queries. However, binary search is usually more efficient for searching as binary search trees will most likely be imperfectly balanced, resulting in slightly worse performance than binary search.

This applies even to balanced binary search treesbinary search trees that balance their own nodes—as they rarely produce optimally -balanced trees—but to a lesser extent. Binary search trees lend themselves to fast searching in external memory stored in hard disks, as binary search trees can effectively be structured in filesystems.

The B-tree generalizes this method of tree organization; B-trees are frequently used to organize long-term storage such as databases and filesystems. Linear search is a simple search algorithm that checks every record until it finds the target value. Linear search can be done on a linked list, which allows for faster insertion and deletion than an array.

Binary search is faster than linear search for sorted arrays except if the array is short. Sorting the array also enables efficient approximate matches and other operations. A related problem to search is set membership. Any algorithm that does lookup, like binary search, can also be used for set membership. There are other algorithms that are more specifically suited for set membership. For approximate results, Bloom filters recursive binary search program in cpp, another probabilistic data structure based on hashing, store a set of keys by encoding the keys using a bit array and multiple hash functions.

Bloom filters are much more space-efficient than bit arrays in most cases and not much slower: However, Bloom filters suffer from false positives. There exist data structures that may improve on binary recursive binary search program in cpp in some cases for both searching and other operations available for sorted arrays. For example, searches, approximate recursive binary search program in cpp, and the operations available to sorted arrays can be performed more efficiently than binary search on specialized data structures such as van Emde Boas treesfusion treestriesand bit arrays.

However, while these operations can always be done at least efficiently on a sorted array regardless of the keys, such data structures are usually only faster because they exploit the properties of keys with a certain recursive binary search program in cpp usually keys that are small integersand thus will be time or space consuming for keys that recursive binary search program in cpp that attribute.

Uniform binary search stores, instead of the lower and upper bounds, the index of the middle element and the change in the middle element from the current iteration to the next iteration. Each step reduces the change by about half. For example, if the array to be searched was [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]the middle element would be 6.

Uniform binary search works on the basis that the difference between the index of middle element of the array and the left and right subarrays is the same. In this case, the middle element of the left subarray [1, 2, 3, 4, 5] is 3 and the middle element of the right subarray [7, 8, 9, 10, 11] is 9. Uniform binary search would store the value of 3 as both indices differ from 6 by this same amount.

The main advantage of uniform binary search is that the procedure can store a table of the differences between indices for each iteration of the procedure, which may improve the algorithm's performance on some systems. It starts by finding the first element with an index that is both a power of two and greater than the target value. Afterwards, recursive binary search program in cpp sets that index as the upper bound, and switches to binary search.

Exponential search works on bounded lists, but becomes an improvement over binary search only if the target value lies near the beginning of the array.

Instead of calculating the midpoint, interpolation search estimates the position of the target value, taking into account the lowest and highest elements in the array as well as length of the array. This is only possible if the array elements are numbers.

It works on the basis that the midpoint is not the best guess in many cases. For example, if the target value is close to the highest element in the array, it is likely to be located near the end of the array. In practice, interpolation search is slower than binary search for small arrays, as interpolation search requires extra computation.

Although its time complexity grows more slowly than binary search, this only compensates for the extra computation for large arrays. Fractional cascading is a technique that speeds up binary searches for the same element for both exact and approximate matching in "catalogs" arrays of sorted elements associated with vertices in graphs. Fractional cascading was originally developed to efficiently solve various computational geometry problems, but it also has been applied elsewhere, in domains such as data mining and Internet Protocol routing.

Fibonacci search is a method similar to binary search that successively shortens the interval in which the maximum of a unimodal function lies. Given a finite interval, a unimodal function, and the maximum length of the resulting interval, Fibonacci search finds a Fibonacci number such that if the interval is divided equally into that many subintervals, the subintervals would be shorter than the maximum length.

After dividing the interval, it eliminates **recursive binary search program in cpp** subintervals in which the maximum cannot lie until one or more contiguous subintervals remain.

Noisy binary search algorithms solve the case where the algorithm cannot reliably compare elements of the array. For each pair of elements, there is a certain probability that the algorithm makes the wrong comparison. Noisy binary search can find the correct position of the target with a given probability that controls the reliability of the yielded position.

InJohn Mauchly made the first recursive binary search program in cpp of binary search as part of the Moore School Lecturesthe first ever set of lectures regarding any computer-related topic. Guibas introduced fractional cascading as a method to solve numerous search problems in computational geometry. Although the basic idea of binary search is comparatively straightforward, the details can be surprisingly tricky When Jon Bentley assigned binary search as a problem in a course for professional programmers, he found that ninety percent failed to provide a correct solution after several hours of working on it, [56] and another study published in shows that accurate code for it is only found in five out of twenty textbooks.

The Java programming language library implementation of binary search had the same overflow bug for more than nine years. In a practical implementation, the variables used to represent the indices will often be of fixed size, and this can result in an arithmetic overflow for very large arrays. If the target value is greater than the greatest value in the array, and the last index of the array is the maximum representable value of Lthe value of L will eventually become too large and overflow.

A similar problem will occur if the target value is smaller than the least value in the array and the first index of the array is the smallest representable value of R. In particular, this means that R must not be an unsigned type if the array starts with index 0. An infinite recursive binary search program in cpp may occur if the exit conditions for the loop are not defined correctly. Once L exceeds Rthe search has failed and must convey the failure of the search.

In addition, the loop must be exited when the target element is found, or in the case of an implementation where this check is moved to the end, checks for whether the search was successful or failed at the end must be in place.

Bentley found recursive binary search program in cpp, in his assignment of binary search, most of the programmers who implemented binary search incorrectly made an error defining the exit conditions. Many languages' standard libraries include binary search routines:.