数组——二分法

一、理论基础

 假设数组 nums 是按升序排列的，给定一个目标值 target，从序列的中间位置 mid 开始比较：

• 如果当前位置 nums[mid] === target，则查找成功；
• 如果 nums[mid] < target，则在 nums[mid + 1] 到 nums[nums.length - 1] 中查找；
• 如果 nums[mid] > target，则在 nums[0] 到 nums[mid - 1] 中查找；
• 重复以上过程，直至找到 target 为止。

当数据量很大时采用该方法，使用二分法查找时，数据须是排好序的。时间复杂度：O(logn) 

二、解题思路 

如果题目规定了数组是有序的，同时题目还强调数组中没有重复元素，满足上面两个条件的时候，就可以考虑使用二分法解题了。

首先定义变量 left, right, mid，left 是查找区间的最左侧下标，right 是查找区间的最右侧下标，mid 是 left 和 right 的中位数。

我们定义 target 是在 [left, right] 区间里，使用 while 循环进行查找，循环成立的条件是 left <= right，有如下两个要点：

• while (left <= right) 这里要使用 <=
• if (nums[mid] > target) 条件成立时， right 要赋值为 mid - 1

其实用 left < right 作为条件也是可以的，但是是两种完全不同的写法。

下面是模板，要灵活套用：

const binarySearch = (nums, target) => {
  let left = 0
  let right = nums.length - 1
  let mid
  while (left <= right) {
    mid = left + ((right - left) >> 1)
    if (nums[mid] > target) {
      right = mid - 1
    } else if (nums[mid] < target) {
      left = mid + 1
    } else {
      return mid
    }
  }
  return -1
}

 三、相关题目

1、力扣 704 题：二分查找

 经典的二分法题目

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
    // right是数组最后一个数的下标，num[right]在查找范围内，是左闭右闭区间
    let mid, left = 0, right = nums.length - 1;
    // 当left=right时，由于nums[right]在查找范围内，所以要包括此情况
    while (left <= right) {
        // 位运算 + 防止大数溢出
        mid = left + ((right - left) >> 1);
        // 如果中间数大于目标值，要把中间数排除查找范围，所以右边界更新为mid-1；如果右边界更新为mid，那中间数还在下次查找范围内
        if (nums[mid] > target) {
            right = mid - 1;  // 去左面闭区间寻找
        } else if (nums[mid] < target) {
            left = mid + 1;   // 去右面闭区间寻找
        } else {
            return mid;
        }
    }
    return -1;
};

2、力扣 35 题：搜索插入位置

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

3、力扣 34 题：在排序数组中查找元素的第一个和最后一个位置

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var searchRange = function(nums, target) {
    if (nums.length === 0) {
        return [-1, -1]
    }
    // 寻找左侧边界
    const findLeftBorder = (nums, target) => {
        let mid
        let left = 0
        let right = nums.length - 1
        while (left <= right) {
            mid = left + ((right - left) >> 1)
            if (nums[mid] < target) {
                left = mid + 1
            } else if (nums[mid] >= target) {
                right = mid - 1
            } else {
                if (nums[mid - 1] === nums[mid]) {
                    right = mid - 1
                } else {
                    return mid
                }
            }
        }
        return -1
    }
    // 寻找右侧边界
    const findRightBorder = (nums, target) => {
        let mid
        let left = 0
        let right = nums.length - 1
        while (left <= right) {
            mid = left + ((right - left) >> 1)
            if (nums[mid] < target) {
                left = mid + 1
            } else if (nums[mid] > target) {
                right = mid - 1
            } else {
                if (nums[mid + 1] === nums[mid]) {
                    left = mid + 1
                } else {
                    return mid
                }
            }
        }
        return -1
    }
    const startIndex = findLeftBorder(nums, target)
    const endIndex = findRightBorder(nums, target)
    return [startIndex, endIndex]
};

4、力扣 69 题：x 的平方根

/**
 * @param {number} x
 * @return {number}
 */
var mySqrt = function(x) {
    let mid, ans
    let left = 0
    let right = x
    while (left <= right) {
        mid = left + ((right - left) >> 1)
        if (mid * mid <= x) {
            ans = mid
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return ans
};

5、力扣 367 题：有效的完全平方数

 

/**
 * @param {number} num
 * @return {boolean}
 */
var isPerfectSquare = function(num) {
    let mid
    let left = 0
    let right = num
    while (left <= right) {
        mid = left + ((right - left) >> 1)
        if (mid * mid < num) {
            left = mid + 1
        } else if (mid * mid > num) {
            right = mid - 1
        } else {
            return true
        }
    }
    return false
};

6、力扣 33 题：搜索旋转排序数组

 

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
  if (nums.length === 1) {
      return nums[0] === target ? 0 : -1
  }
  let mid
  let left = 0
  let right = nums.length - 1
  // 假如从中间将数组分成两部分，左半部分和右半部分一定有一个数组是有序的
  // 通过判断哪部分数组是有序的，target 在不在有序数组中，来确定二分法的上界和下界
  while (left <= right) {
      mid = left + ((right - left) >> 1)
      if (nums[mid] === target) {
          return mid
      }
      if (nums[left] <= nums[mid]) {
          if (nums[left] <= target && nums[mid] >= target) {
              right = mid - 1
          } else {
              left = mid + 1
          }
      } else {
          if (nums[mid] <= target && nums[right] >= target) {
              left = mid + 1
          } else {
              right = mid - 1
          }
      }
  }
  return -1
};

四、心得体会

要根据题目条件灵活地确定左侧区间和右侧区间。