二分查找
- 递归实现
- 区间为左闭右闭
- 区间为左闭右开
public class BinarySearchTest {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
int index1 = binarySearch1(arr, 5);
System.out.println(index1);
int index2 = binarySearch2(arr, 5);
System.out.println(index2);
int index3 = binarySearchRecursion(arr, 5);
System.out.println(index3);
}
//递归解法
public static int binarySearchRecursion(int[] arr, int target) {
return binarySearch3(arr, 0, arr.length - 1, target);
}
public static int binarySearch3(int[] arr, int left, int right, int target) {
if(left > right) return -1;
int mid = left + (right - left) / 2;
if(arr[mid] > target) {
return binarySearch3(arr, left, mid - 1, target);
}else if(arr[mid] < target) {
return binarySearch3(arr, mid + 1, right, target);
}else {
return mid;
}
}
//区间:左闭右闭
public static int binarySearch1(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while(left <= right) {
int mid = left + (right - left) / 2;
if(arr[mid] == target) {
return mid;
} else if (arr[mid] < target) {
left = mid + 1;
}else{
right = mid - 1;
}
}
return -1;
}
//区间:左闭右开
public static int binarySearch2(int[] arr, int target) {
int left = 0;
int right = arr.length;
while(left < right) {
int mid = left + (right - left) / 2;
if(target < arr[mid]) {
right = mid;
}else if(target > arr[mid]) {
left = mid + 1;
}else{
return mid;
}
}
return -1;
}
}
扩展题
数组中有多个相同的目标值,把这些值的下标找出来,如{1,2,2,3,4} 目标值是2,则返回{1,2}
import java.util.ArrayList;
import java.util.List;
public class BinarySearchExtension {
public static void main(String[] args) {
int[] arr = {1,2,2,3,4,4,4};
List<Integer> result = binarySearchRecursion(arr, 3);
System.out.println(result);
}
public static List binarySearchRecursion(int[] arr, int target) {
return binarySearch1(arr, 0, arr.length - 1, target);
}
public static List binarySearch1(int[] arr, int left, int right, int target) {
if(left > right) {
return new ArrayList<>();
}
int mid = left + (right - left) / 2;
if(arr[mid] > target) {
return binarySearch1(arr, left, mid - 1, target);
}else if(arr[mid] < target) {
return binarySearch1(arr, mid + 1, right, target);
}else{
int temp1 = mid - 1;
int temp2 = mid + 1;
int arrLen = arr.length;
List<Integer> result = new ArrayList<>();
//扫描mid左边的值
while(temp1 >= 0 && arr[temp1] == target) {
result.add(temp1);
temp1--;
}
result.add(mid);
//扫描mid右边的值
while(temp2 < arrLen && arr[temp2] == target) {
result.add(temp2);
temp2++;
}
return result;
}
}
}
时间复杂度
每次查找,元素个数减小一半,即n,n/2,n/4,…, n/2^ k,k就是循环的次数,取n/2^ k=1,即k=logn(以2为底),因此时间复杂度为O(logN)
插值查找
二分查找中取中间元素mid= left + (right - left)/ 2
,设想这样一个例子:数据为1到1000,查找元素1,那么将会进行好几次循环才能找到1。于是有个改进的算法即插值算法:mid=left + (right - left) * (target -arr[left]) / (arr[right] - arr[left])
,target是要找到目标值。
对于数据量比较大,关键字分布比较均匀的查找来说,采用插值查找速度较快。关键字分布不均匀的情况下,该方法不一定比二分查找效率高。