二分查找

二分查找针对的是一个有序的数据集合，查找思想有点类似分治思想。每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0。

时间复杂度：O(log(n))

• 假设数据大小为n，每次查找数据范围缩小一半，最坏情况缩小到空才停止。得出等比数列：n/2^k = 1， k就是缩小的次数，时间复杂度O(k),通过n/2^ k = 1,得k = log2n,所以时间复杂度O(log(n))。

对数时间复杂度

• 有的时候甚至比时间复杂度是常量级 O(1) 的算法还要高效，
• 比如 n 等于 2 的 32 次方，大约是 42 亿。用二分查找一个数据，最多需要比较 32 次。

1.二分查找应用场景

• 二分查找依赖的是顺序表结构，简单点说就是数组。主要原因是二分查找算法需要按照下标随机访问元素
• 二分查找针对的是有序数据
• 数据量太小不适合二分查找
• 数据量太大也不适合二分查找，太大的数据用数组存储就比较吃力了，也就不能用二分查找了
• 二分查找更适合处理静态数据，也就是没有频繁的数据插入、删除操作。

2.二分查找4种变形问题

• 查找第一个值等于给定值的元素
• 查找最后一个值等于给定值的元素
• 查找第一个大约等于给定值的元素
• 查找最后一个小于等于给定值的元素

变体一：查找第一个值等于给定值的元素

public int bsearch(int[] a, int n, int value) {
  int low = 0;
  int high = n - 1;
  while (low <= high) {
    int mid =  low + ((high - low) >> 1);
    if (a[mid] > value) {
      high = mid - 1;
    } else if (a[mid] < value) {
      low = mid + 1;
    } else {
      if ((mid == 0) || (a[mid - 1] != value)) return mid;
      else high = mid - 1;
    }
  }
  return -1;
}

** 变体二：查找最后一个值等于给定值的元素**

public int bsearch(int[] a, int n, int value) {
  int low = 0;
  int high = n - 1;
  while (low <= high) {
    int mid =  low + ((high - low) >> 1);
    if (a[mid] > value) {
      high = mid - 1;
    } else if (a[mid] < value) {
      low = mid + 1;
    } else {
      if ((mid == n - 1) || (a[mid + 1] != value)) return mid;
      else low = mid + 1;
    }
  }
  return -1;
}

如果 a[mid] 这个元素已经是数组中的最后一个元素了，那它肯定是我们要找的；如果 a[mid] 的后一个元素 a[mid+1] 不等于 value，那也说明 a[mid] 就是我们要找的最后一个值等于给定值的元素。

变体三：查找第一个大于等于给定值的元素

public int bsearch(int[] a, int n, int value) {
  int low = 0;
  int high = n - 1;
  while (low <= high) {
    int mid =  low + ((high - low) >> 1);
    if (a[mid] >= value) {
      if ((mid == 0) || (a[mid - 1] < value)) return mid;
      else high = mid - 1;
    } else {
      low = mid + 1;
    }
  }
  return -1;
}

**变体四：查找最后一个小于等于给定值的元素 **

public int bsearch7(int[] a, int n, int value) {
  int low = 0;
  int high = n - 1;
  while (low <= high) {
    int mid =  low + ((high - low) >> 1);
    if (a[mid] > value) {
      high = mid - 1;
    } else {
      if ((mid == n - 1) || (a[mid + 1] > value)) return mid;
      else low = mid + 1;
    }
  }
  return -1;
}

5.问题1：如何在 1000 万个整数中快速查找某个整数？（内存限制是 100MB，每个数据大小是 8 字节）

• 将数据存储在数组中，内存占用差不多是 80MB，数据从小到大排序，然后再利用二分查找算法

问题2：如何快速定位出一个 IP 地址的归属地？

• 如果 IP 区间与归属地的对应关系不经常更新，我们可以先预处理这 12 万条数据，让其按照起始 IP 从小到大排序（转化为 32 位的整型数）
• 转化为第四种变形问题，可以先通过二分查找，找到最后一个起始 IP 小于等于这个 IP 的 IP 区间，然后，检查这个 IP 是否在这个 IP 区间内