174b83f764
Cleans the Java implementation of binary search to be more consistent with styles and to avoid unnecessary boxing of int types
97 lines
2.7 KiB
Java
97 lines
2.7 KiB
Java
package search;
|
|
|
|
import java.util.Arrays;
|
|
import java.util.Random;
|
|
import java.util.concurrent.ThreadLocalRandom
|
|
import java.util.stream.IntStream;
|
|
|
|
import static java.lang.String.format;
|
|
|
|
/**
|
|
*
|
|
*
|
|
*
|
|
* Binary search is one of the most popular algorithms
|
|
* The algorithm finds the position of a target value within a sorted array
|
|
*
|
|
* Worst-case performance O(log n)
|
|
* Best-case performance O(1)
|
|
* Average performance O(log n)
|
|
* Worst-case space complexity O(1)
|
|
*
|
|
*
|
|
* @author Varun Upadhyay (https://github.com/varunu28)
|
|
* @author Podshivalov Nikita (https://github.com/nikitap492)
|
|
*
|
|
* @see SearchAlgorithm
|
|
* @see IterativeBinarySearch
|
|
*
|
|
*/
|
|
|
|
class BinarySearch implements SearchAlgorithm {
|
|
|
|
/**
|
|
*
|
|
* @param array is an array where the element should be found
|
|
* @param key is an element which should be found
|
|
* @param <T> is any comparable type
|
|
* @return index of the element
|
|
*/
|
|
@Override
|
|
public <T extends Comparable<T>> int find(T array[], T key) {
|
|
return search(array, key, 0, array.length);
|
|
}
|
|
|
|
/**
|
|
* This method implements the Generic Binary Search
|
|
*
|
|
* @param array The array to make the binary search
|
|
* @param key The number you are looking for
|
|
* @param left The lower bound
|
|
* @param right The upper bound
|
|
* @return the location of the key
|
|
**/
|
|
private <T extends Comparable<T>> int search(T array[], T key, int left, int right){
|
|
if (right < left) return -1; // this means that the key not found
|
|
|
|
// find median
|
|
int median = (left + right) >>> 1;
|
|
int comp = key.compareTo(array[median]);
|
|
|
|
if (comp < 0) {
|
|
return search(array, key, left, median - 1);
|
|
}
|
|
|
|
if (comp > 0) {
|
|
return search(array, key, median + 1, right);
|
|
}
|
|
|
|
return median;
|
|
}
|
|
|
|
// Driver Program
|
|
public static void main(String[] args) {
|
|
// Just generate data
|
|
Random random = ThreadLocalRandom.current();
|
|
|
|
int size = 100;
|
|
int maxElement = 100000;
|
|
|
|
int[] integers = IntStream.generate(() -> r.nextInt(maxElement)).limit(size).sorted().toArray();
|
|
|
|
// The element that should be found
|
|
int shouldBeFound = integers[r.nextInt(size - 1)];
|
|
|
|
BinarySearch search = new BinarySearch();
|
|
int atIndex = search.find(integers, shouldBeFound);
|
|
|
|
System.out.println(format(
|
|
"Should be found: %d. Found %d at index %d. An array length %d",
|
|
shouldBeFound, integers[atIndex], atIndex, size
|
|
));
|
|
|
|
int toCheck = Arrays.binarySearch(integers, shouldBeFound);
|
|
System.out.println(format("Found by system method at an index: %d. Is equal: %b", toCheck, toCheck == atIndex));
|
|
}
|
|
}
|