数据结构与算法之美 | 学习笔记12 —— 二分查找

一、二分查找（Binary Search）

针对有序的数据集合，每次都跟区间中间的元素对比，直到找到元素，或待查找的区间缩小为0。

时间复杂度：每次查找后数据都为原来的一半：$n,\frac{n}{2},\frac{n}{4},...\frac{n}{2^k},$，每次缩小操作只涉及两个数据的比较，因此经过k次区间缩小操作，时间复杂度为$O(k)$，通过$\frac{n}{2^k}=1$，时间复杂度为$O(logn)$。
对于$O(logn)$，即使数据量非常大，对应的$logn$也很小。

二、二分查找的实现

1. 循环实现

当有序数组中不存在重复元素时：

public int bsearch(int[] a, int n, int value) {
  int low = 0;
  int high = n - 1;

  while (low <= high) {
    int mid = (low + high) / 2;
    if (a[mid] == value) {
      return mid;
    } else if (a[mid] < value) {
      low = mid + 1;
    } else {
      high = mid - 1;
    }
  }

  return -1;
}

代码注意点：

1. 退出条件low<=high，要包括等号；
2. 其中，mid = (low + high) / 2的写法，如果low和high比较大，两者之和有可能溢出，应该改进为low+(high-low)/2。更进一步优化，可以改为low+((high-low)>>1)，其中>>为二进制后移一位的位运算，因为相比较除法，计算机处理位运算快得多；
3. low和high的更新：low=mid+1, high=mid-1。

2. 递归实现

用递归实现二分查找：

// 二分查找的递归实现
public int bsearch(int[] a, int n, int val) {
  return bsearchInternally(a, 0, n - 1, val);
}

private int bsearchInternally(int[] a, int low, int high, int value) {
  if (low > high) return -1;

  int mid =  low + ((high - low) >> 1);
  if (a[mid] == value) {
    return mid;
  } else if (a[mid] < value) {
    return bsearchInternally(a, mid+1, high, value);
  } else {
    return bsearchInternally(a, low, mid-1, value);
  }
}

二、 局限性

1. 二分法只适用于有序数组，不适用于链表等其他结构；
2. 如果数组集合有频繁的插入删除操作，要保证每次操作之后数据仍有序；
3. 适用于数据量比较大的情况，数据量小的可以用顺序遍历法；但当每一个元素的位数很多时，比较每两个字符串大小代价太大，采用二分查找更佳；
4. 对于数据量太大的情况不适用，需要申请连续的大空间数组来存储数据。

三、二分查找的变形问题

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 == 0) || (a[mid - 1] != value)) return mid;
      else high = mid - 1;
    }
  }
  return -1;
}

对于第11行代码的解释：当mid值为0，那么这个元素时数组的第一个元素；当mid不为0，但a[mid]前一个数等于value时，那么要找的元素在前面[low, mid-1]的区间。

2. 查找最后一个值等于给定值的元素

与前边同理：

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;
}

3. 查找第一个大于等于给定值的元素

此时a[mid] >value和a[mid] = value的情况合并在一起。

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;
}

4. 查找最后一个小于等于给定值的元素

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;
}

四、应用

问：给定类似下列数据12万条，如何快速定位出一个IP地址的归属地？

[202.102.133.0, 202.102.133.255]  山东东营市 
[202.102.135.0, 202.102.136.255]  山东烟台 
[202.102.156.34, 202.102.157.255] 山东青岛 
[202.102.48.0, 202.102.48.255] 江苏宿迁 
[202.102.49.15, 202.102.51.251] 江苏泰州 
[202.102.56.0, 202.102.56.255] 江苏连云港

解答：首先对所有地址进行预处理排序，因为IP地址可以转化为32位的整型数，可以按照大小关系进行排序。之后再用“变形一：查找最后一个小于等于某个给定值的元素”进行二分查找。

二分查找因为使用数组，只存储数据，在内存上更节省；但对内存要求宽的情况下，更倾向用散列表或者查找二叉树。