时间复杂度
- 二分查找时,第1次二分后的范围为N/2,第2次二分后的范围为N/4,第3次二分后的范围为N/8…
- 若未找到,则在最后范围为1时结束
- 时间复杂度为 O(logN)
题目一
题目
在一个有序数组中,找某个数是否存在
解题思路
- 定义三个指针
- L代表当前查找范围的左边界
- R代表当前查找范围的右边界
- mid 代表当前查找范围的中点位置
- 比较mid指针所在位置的值和目标值
- 如果等于当前值,那么结束循环,返回true
- 如果小于当前值,那么下次查找的范围应该是[mid+1]~[R]
- 如果大于当前值,那么下次查找的范围应该是[L]~[mid-1]
- 遍历结束后,当L和R来到同一位置,那么判断L位置的值是否等于目标值
代码
public static boolean exist(int[] array,int num){
//如果数组为空则结束
if (array == null || array.length == 0){
return false;
}
//定义左右指针和中间指针
int L = 0;
int R = array.length - 1;
int mid = 0;
while (L < R){
//计算当前mid的位置,不用L+R/2的方式是防止L、R过大导致内存溢出
mid = L + ((R-L) >> 1);// mid = (L+R)/2
if (array[mid] == num){
return true;
} else if (array[mid] > num){
//array[mid]比目标值大,说明目标值在二分左侧,右边界移到mid-1位置
R = mid-1;
} else {
//array[mid]比目标值小,说明目标值在二分右侧,左边界移到mid+1的位置
L = mid +1;
}
}
//遍历后若未找到,则判断L位置的值是否等于目标值
return array[L] == num;
}
题目二
题目
在一个有序数组中,找>=某个数最左侧的位置
比如:1 2 2 3 3 4 5 6,2 => 目标位置为第一个2,索引值为1
解题思路
- 同样定义L、R、mid 指针
- 定义int类型变量index,用于记录>=目标值最左侧的位置
- 比较mid指针所在位置的值和目标值
- 如果小于当前值,那么下次查找的范围应该是[mid+1]~[R]
- 如果大于等于当前值,那么用index变量记录当前mid值,继续查找,下次查找的范围应该是[L]~[mid-1]
代码
public static int nearIndex(int[] array, int num){
//判断数组为空
if (array == null || array.length == 0){
return -1;
}
int L = 0;
int R = array.length - 1;
int mid = 0;
int index = -1;
//如果当前mid位置的数>=num,那么记录当前位置的索引,R=mid-1,继续二分向左寻找
//如果当前mid位置的数<num,那么L=mid+1,向右寻找
while (L <= R){
mid = L + ((R-L) >> 1);
if (array[mid] >= num){
index = mid;
R = mid - 1;
} else {
L = mid + 1;
}
}
return index;
}
题目三
题目
在一个有序数组中,找<=某个数最右侧的位置
比如:1,2,3,3,4,4,6,6,6,8,8,9 -> 6 结果为8
解题思路
- 同样定义L、R、mid 指针
- 定义int类型变量index,用于记录<=目标值最右侧的位置
- 比较mid指针所在位置的值和目标值
- 如果大于当前值,那么下次查找的范围应该是[L]~[mid-1]
- 如果小于等于当前值,那么用index变量记录当前mid值,继续查找,下次查找的范围应该是[mid+1]~[R]
代码
public static int nearIndex(int[] array, int num){
//判空
if(array == null || array.length == 0){
return -1;
}
int L = 0;
int R = array.length - 1;
int mid = 0;
int index = -1;
while (L <= R){
//计算中间值
mid = L + ( (R-L) >> 1);
//如果当前值<=目标值,则记录该值,L=mid+1,继续向右找
//如果当前值>目标值,则R=mid-1,继续向左找
if (array[mid] <= num){
index = mid;
L = mid +1;
}else {
R = mid -1;
}
}
return index;
}
题目四
题目
局部最小值问题
一个无序数组,相邻两个数都不相等,要求返回任意一个局部最小值(比左右两边的值都小)
解题思路
- 先判断 arr[0] 是否小于 arr[1],若小于,则0位置即为局部最小值,若不小于,则0位置 ~ 1位置为下降趋势
- 继续判断 arr[n-1] 是否小于 arr[n-2],若小于,则n-1位置即为局部最小值,若不小于,则 n-2位置 ~ n-1位置区间为上升趋势
- 若0~1下降,n-2 ~ n-1上升,那么局部最小值必定存在
- 取中间值 mid
- 若 arr[mid] < arr[mid+1] 且 arr[mid] < arr[mid-1],则mid为局部最小值,返回mid
- 若不是上述情况,则mid必有一侧比mid小,选取这一侧继续二分
代码
public static int getLessIndex(int[] array){
//判空
if (array == null || array.length == 0){
return -1;
}
if (array[0] < array[1]){
return 0;
} else if(array[array.length-1] < array[array.length-2]){
return array.length-1;
}
int L = 1;
int R = array.length - 2;
int mid = 0;
while (L <= R){
mid = L + ((R-L) >> 1);
//如果array[mid] > array[mid+1],那么L=mid+1,继续在右侧二分
if (array[mid] > array[mid+1]){
L = mid + 1;
} else if (array[mid] > array[mid-1]){
//如果array[mid] > array[mid-1],那么R=mid-1,继续在左侧二分
R = mid - 1;
}else {
return mid;
}
}
return L;
}
public static void main(String[] args) {
int result = getLessIndex(new int[]{2, 1, 3, 5, 6, 4, 8, 9});
System.out.println(result);
}
运行结果
1