I've developed a custom BinarySearch class to avoid the usual bugs like off-by-one errors and infinite loops that I often encounter. While the standard Java Development Kit (JDK) does have its own binary search implementations for arrays and lists, I find that in some scenarios—especially while tackling problems on LeetCode—a more generalized bisection algorithm is necessary. This can include searching not just sorted arrays but also specific value domains, such as positive integers, longs, or doubles. For instance, I created a method for calculating square roots that uses this binary search approach.
Here's a simplified example:
double mySqrt(double x) {
return BinarySearch.forDoubles()
.insertionPointFor((lo, mid, hi) -> Double.compare(x, mid * mid))
.floor(); // finds max value such that square <= x
}
Some key features of this implementation include the guaranteed convergence in 64 steps or less and the flexibility to find floor or ceiling values when no exact match is found. This allows me to focus on the actual algorithm instead of worrying about technical details.
I'm curious if anyone else has found a similar need for a more flexible binary search system in their coding practices?
3 Answers
I get what you're saying, but I've found that sometimes a skip list works better for my needs than a binary search, especially for bigger datasets. Sure, it requires an upfront cost for construction, but if you're searching multiple times (more than 10-20), it really pays off with fewer hops. If I'm only doing a few searches, I usually stick with the JDK's offerings.
This is a gem of an idea! The bitwise method you mentioned for doubles is fascinating. Could you break down exactly how it guarantees 64-step convergence? That sounds super efficient!
For sure! The strategy revolves around using the precise bits representing doubles instead of just simple arithmetic averages, which can fail me in edge cases. By halving the representation space iteratively, the algorithm is guaranteed to pinpoint exact values much faster.
This sounds interesting! You're correct about the JDK handling basic binary searches, but your implementation could offer deeper insights. The issue you mentioned with double precision and control over constructs is a smart touch. It sounds like it could save a lot of headache with problematic domains!
Definitely! The complexity of floating-point arithmetic can be tricky, and your class could prevent those pitfalls. I love how it lets you manipulate values without diving into all the nitty-gritty of integer math.
Totally agree! The JDK binary search is fine for basic use cases, but it doesn't really cover special cases like floating-point comparisons or finding ranges. When I have specific conditions, I lean on more specialized tools too.