二分法及题目

时间复杂度

• 二分查找时，第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