leetcode 算法总结--二分查找

33. 搜索旋转排序数组

 这道题的关键是先找出有序的，然后判断target是否是在这个有序的，不是的话则是在另一段

 

 

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
    let len = nums.length;
    let left = 0;
    let right = len - 1;
    while(left <= right) {
        let mid = Math.round((left + right) / 2);
        if(nums[mid] === target) return mid;
        if(nums[left] <= nums[mid]) {
            if(nums[left] <= target && target < nums[mid]) {
                right = mid - 1;
            }else {
                left = mid + 1;
            }
        }else {
            if(nums[mid] < target && target <= nums[right]) {
                left = mid + 1;
            }else {
                right = mid -1;
            }
        }
    }
    return -1
};

34. 在排序数组中查找元素的第一个和最后一个位置

 

这道题的关键在于，我们利用二分查找出target值后，怎么继续利用二分查找找到第一个target和最后一个target。

思路就分成两次寻找。

第一次，找第一个target：在找到target后，right = mid -1;

第二次，找最后一个target：在找到target后，left = mid + 1;

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var searchRange = function(nums, target) {
    let leftIndex = findLeftTarget(nums, target);
    let rightIndex = findRightTarget(nums, target);
    return [leftIndex, rightIndex]
};

function findLeftTarget(nums, target) {
    let len = nums.length;
    let left = 0; 
    let right = len - 1;
    let res = -1;
    while(left <= right) {
        let mid = Math.round((left + right) / 2);
        if(nums[mid] === target) {
            right = mid -1;
            res = mid; // 记录最新的target的位置
        } else if(nums[left] <= target && target < nums[mid]) {
            right = mid -1;
        } else if(nums[mid] < target && target <= nums[right]){
            left = mid + 1;
        } else {
            break; // 都不符合，退出循环
        }
    }
    return res;
}
function findRightTarget(nums, target) {
    let len = nums.length;
    let left = 0; 
    let right = len - 1;
    let res = -1;
    while(left <= right) {
        let mid = Math.round((left + right) / 2);
        if(nums[mid] === target) {
            left = mid + 1;
            res = mid; // 记录最新的target的位置
        } else if(nums[left] <= target && target < nums[mid]) {
            right = mid -1;
        } else if(nums[mid] < target && target <= nums[right]){
            left = mid + 1;
        } else {
            break; // 都不符合，退出循环
        }
    }
    return res;
}

封装一下代码

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var searchRange = function(nums, target) {
    let leftIndex = findTarget(nums, target, 'left');
    let rightIndex = findTarget(nums, target, 'right');
    return [leftIndex, rightIndex]
};

function findTarget(nums, target, bound) {
    let len = nums.length;
    let left = 0; 
    let right = len - 1;
    let res = -1;
    while(left <= right) {
        let mid = Math.round((left + right) / 2);
        if(nums[mid] === target) {
            if (bound === 'left') { // 找第一个的
                right = mid - 1;
            } else { // 找最后一个的
                left = mid + 1;
            } 
            res = mid; // 记录最新的target的位置
        } else if(nums[left] <= target && target < nums[mid]) {
            right = mid -1;
        } else if(nums[mid] < target && target <= nums[right]){
            left = mid + 1;
        } else {
            break; // 都不符合，退出循环
        }
    }
    return res;
}

35. 搜索插入位置

本题的关键在于找到target后，返回target索引，否则返回left。

比较简单，不写了。

69. x 的平方根

这道题的关键在于，

初始化left = 1;right = x;

如果mid * mid === x, 则mid为所求。

当退出循环后，没找到mid，只能说明不存在刚刚好mid * mid === x，所以要返回left - 1或者是right。 为什么？ 因为 值肯定就处于right 和left直接（退出循环的时候，left = right+1）;

而要取整，所以就只能取左边的，及right 或者 left -1;

/**
 * @param {number} x
 * @return {number}
 */
var mySqrt = function(x) {
  if(x === 0) return x
  let left = 0
  let right = x
  let res = 0
  while(left <= right) {
    let mid = Math.floor((left + right) / 2)
    if(mid * mid === x ||(mid * mid < x && (mid + 1) * (mid + 1) > x)) {
      res = mid
      return res
    }else if(mid * mid > x) {
      right = mid
    }else if(mid * mid < x) {
      left = mid + 1
    }
  }
  return res
};

74. 搜索二维矩阵

这道题又两种二分查找的思路，

第一种是先利用二分查找在哪一行，然后再在这一行当中利用二分查找。

第二种是将多行数组拼接成一个数组，然后二分查找。

太简单了，不写。

81. 搜索旋转排序数组 II

这道题跟之前那道是类似的，只不过多了个重复元素，所以就多了些判断。
因为会出现这种情况。

例如 ：

nums=[3,1,2,3,3,3,3]。target=2，首次二分时无法判断区间[0,3] 和区间 [4,6] 哪个是有序的。

对于这种情况，我们只能将当前二分区间的左边界加一，右边界减一，然后在新区间上继续二分查找。

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
    let len = nums.length;
    let left = 0;
    let right = len - 1;
    while(left <= right) {
        let mid = Math.round((left + right) / 2);
        if(nums[mid] === target){
             return true;
        }else if(nums[left] === nums[mid] && nums[mid] === nums[right]) {
            left++;
            right--;
        }else if(nums[left] <= nums[mid]) {
            if(nums[left] <= target && target < nums[mid]) {
                right = mid - 1;
            }else {
                left = mid + 1;
            }
        }else {
            if(nums[mid] < target && target <= nums[right]) {
                left = mid + 1;
            }else {
                right = mid -1;
            }
        }
    }
    return false
};

在二分查找的每一步中，左边界为 low，右边界为high，区间的中点为 pivot，最小值就在该区间内。我们将中轴元素 。

nums[pivot]与右边界元素 nums[high]进行比较，可能会有以下的三种情况：

第一种情况是 nums[pivot]< nums[high]

如下图所示，这说明 nums[pivot] 是最小值右侧的元素，因此我们可以忽略二分查找区间的右半部分。

第二种情况是 nums[pivot]>nums[high]。如下图所示，这说明
nums[pivot] 是最小值左侧的元素，因此我们可以忽略二分查找区间的左半部分。

 

由于数组不包含重复元素，并且只要当前的区间长度不为 1。
pivot 就不会与high 重合；而如果当前的区间长度为 1，这说明我们已经可以结束二分查找了。因此不会存在 nums[pivot]=nums[high] 的情况。

当二分查找结束时，我们就得到了最小值所在的位置。