二分法及题目

时间复杂度

  • 二分查找时,第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
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值