In today’s share about searching algorithms, AlgoMonster will focus on the variations of one of the most common searching algorithms-binary search. To find out more useful information about this topic, please finish reading this article.
Tailed Binary Search
The half-interval search variant offers 1-2% performance gains without any drawbacks. Actually, it has the same number and type of key checks as standard binary search.
Uniform binary search
Instead of storing in the lower or upper bounds, it stores only the difference in index of the middle elements from the current to the next iteration. It will calculate the differences beforehand by a lookup table. If the array to search is [1, 2, 3, 5, 6, 7, 8, 9, 10 11], then the middle element (m), would be 6. The middle element (m) of the left subarray is [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,] and the middle (m) of the right subarray is [7, 8, 9 10, 11]. The uniform binary search would store 3 because the indices differ by 6 by the same amount.
The algorithm adds or subtracts the change from the index for the middle element to reduce search space. Usually, uniform binary searches could probably be quicker on systems that calculating the midpoint is not easy to finish.
Exponential search expands the half-interval search to an unbounded list. It begins by searching for the first element that has an index that is greater than the target value and a power of 2. Then, it sets the index as its upper bound and switches to binary searching. Log2x+1 iterations are required before a binary search can be started. So, the binary search takes only log 2x iterations, where x represents the target value. Exponential search is a method that works with bound lists. However, it can be better than binary if the target value is near the beginning of an array.
Interpolation search, which is a different method than calculating the midpoint of an array, estimates the target value’s position by using interpolation search. It takes into account both the highest and lowest elements of the array, as well as the length of the array. The midpoint may not be the best guess in all cases. If the target value is near the highest element of an array, it will likely be at the end.
Interpolation search can be slower than half-interval search when it comes to small arrays. This is because interpolation requires more computation. Although interpolation search is slower than binary search in terms of time complexity, this can only be compensated for by the additional computation required for large arrays.
Well, fractional Cascading is a method that speeds up binary searches to find the same element in multiple sorted arrays.
Fractional cascading was initially developed to solve various problems in computational geometry. In addition, fractional Cascading can also be applicable in other areas, such as data mining or Internet Protocol Routing.
Generalization to graphs
Binary search is suitable for certain graph types, with the target value stored in a vertex and not an array element. In fact, BSTs are an example of such a generalization. When a vertex (node), in a tree is queried it learns whether the vertex is the target or which subtree it would be found in. This can be extended to say that given an undirected graph with a positively weighted target vertex, the algorithm will either learn that the vertex is equal to the target or that the incident edge is the shortest path to the target.
The half-interval search algorithm uses the graph as a path. In fact, binary search trees can also be applicable when the query vertex is not equal to the target. There is an algorithm that will find the target vertex for all undirected graphs with positively weighted graphs in the worst case.
Noisy binary search
Noisy binary search algorithms are able to solve this problem. There is a chance that the algorithm will make a wrong comparison for each pair of elements. A noisy half-interval search can locate the correct target position with a certain probability that controls its reliability.
Quantum binary search
When performing half-interval search, classic computers are limited to the worst case of log2 n+1 iterations. Quantum algorithms for binary are still bound to a certain proportion of log2n queries (representing iterations from the classical procedure). However, the constant factor is lower than one which allows for lower time complexity.
Boundless binary search
Technically, the boundless binary search is more efficient than the standard one. In fact, it has a loop that includes 1 key check, 1 integer check, and (on average), 1.5 integer assignments. While performance gains will vary depending upon many factors, they should not be less than 5% when comparing 32-bit integers.
Quaternary boundless binary research
While the boundless binary search is more robust than the boundless, it has fewer calculations and key checks. It has a higher performance than the boundless search in most tests compared to 32-bit integers.
Inbound binary search
The boundless binary search can’t use the same mid-to-1 optimization that was used in standard search due to boundary issues. This problem is solved by the inbound half-interval search. It also has fewer key checks than the boundless search. It’s slower than the quaternary binary, but it can still be useful when it comes to strings and 64-bit integers.
Interpolated binary search
If you have an even distribution, you can make an educated guess about the location of the index. This is a costly check, so my version only checks once. The interpolated half-interval search will not outperform other binary queries on arrays of less than 100 elements due to the cost of the initial check and errors correction.
Tailing linear search
A linear search has one loop that contains 1 key check and one integer increment. And we terminate a linear search early and it requires on average 3 loops to find a match within an array of 6 elements. The loop is cheaper and it’s a good idea to switch to a linear search after a binary search narrows the search area to 6 elements. This approach has the downside that it can lead to more key checks. Therefore, this approach can prove counterproductive when you compare strings with integers.