非递归
int find(int[] arr, int target){
int l=0, r=arr.length-1;
while(l<=r){
int mid = (r-l)/2 + l;
if(arr[mid] == target) return mid;
if(arr[mid] > target) r = mid-1;
if(arr[mid] < target) l = mid+1;
}
return -1;
}
package com.algorithm.search;
public class BinarySearchNotRecursive {
private BinarySearchNotRecursive() {
}
// 二分查找法,在有序数组arr中,查找target
// 如果找到target,返回相应的索引index
// 如果没有找到target,返回-1
public static int find(Integer[] arr, Integer target) {
// 在arr[l...r]之中查找target
int l = 0, r = arr.length - 1;
while (l <= r) {
// 防止极端情况下的整形溢出,使用下面的逻辑求出mid
int mid = l + (r - l) / 2;
if (arr[mid].compareTo(target) == 0) {
return mid;
}
if (arr[mid].compareTo(target) > 0) {
r = mid - 1;
} else if (arr[mid].compareTo(target) < 0) {
l = mid + 1;
}
}
return -1;
}
// 测试非递归的二分查找算法
public static void main(String[] args) {
int N = 1000;
Integer[] arr = new Integer[N];
for (int i = 0; i < N; i++)
arr[i] = new Integer(i);
// 对于我们的待查找数组[0...N)
// 对[0...N)区间的数值使用二分查找,最终结果应该就是数字本身
// 对[N...2*N)区间的数值使用二分查找,因为这些数字不在arr中,结果为-1
for (int i = 0; i < 2 * N; i++) {
int v = BinarySearchNotRecursive.find(arr, new Integer(i));
if (i < N) {
System.out.print(i);
System.out.println(v == i);
} else {
System.out.print(i);
System.out.println(v == -1);
}
}
return;
}
}
递归
int find(int[] arr, int target){
return find(arr, 0, arr.length-1, target);
}
int find(int[] arr, int l, int r, int target){
if( l > r) return -1;
int mid = (r-l)/2 + l;
if(arr[mid] == target) return mid;
else if(arr[mid] > target) return find(arr, l, mid—1, target);
else returnfind(arr, mid+1, r, target);
}
package com.algorithm.search;
public class BinarySearchRecursive {
private BinarySearchRecursive() {
}
public static int find(Integer[] arr, Integer target) {
return find(arr, 0, arr.length - 1, target);
}
private static int find(Integer[] arr, int l, int r, Integer target) {
if (l > r) return -1;
// 防止极端情况下的整形溢出,使用下面的逻辑求出mid
int mid = l + (r - l) / 2;
if (arr[mid].compareTo(target) > 0) {
return find(arr, l, mid - 1, target);
} else if (arr[mid].compareTo(target) < 0) {
return find(arr, mid + 1, r, target);
} else { // arr[mid].compareTo(target) == 0
return mid;
}
}
// 测试递归的二分查找算法
public static void main(String[] args) {
int N = 1000;
Integer[] arr = new Integer[N];
for (int i = 0; i < N; i++)
arr[i] = new Integer(i);
// 对于我们的待查找数组[0...N)
// 对[0...N)区间的数值使用二分查找,最终结果应该就是数字本身
// 对[N...2*N)区间的数值使用二分查找,因为这些数字不在arr中,结果为-1
for (int i = 0; i < 2 * N; i++) {
int v = BinarySearchRecursive.find(arr, new Integer(i));
if (i < N) {
System.out.print(i);
System.out.println(v == i);
} else {
System.out.print(i);
System.out.println(v == -1);
}
}
return;
}
}