数据结构与算法之美【10】-二分查找

二分查找针对的是一个有序的数组，查找思想有点类似分治思想。每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0。 它的时间复杂度也是 O(logn)。

虽然二分查找的非常诱人，但也有它自己的应用场景局限性：

• 二分查找依赖的是数组结构，因为二分查找特别依赖于下标随机访问元素
• 二分查找针对的是有序数据，如果数据无序，需要先进行排序处理，相应的，复杂度也会增加。
• 数据量太小不适合二分查找，可以直接遍历数组。
• 数据量太大也不适合二分查找，因为其底层需要依赖数组这种数据结构

目录

一、二分查找的实现方式

1、非递归实现

2、递归实现

二、二分查找的变体

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

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

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

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

---

一、二分查找的实现方式

场景中数据有序且无重复元素：

1、非递归实现

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

2、递归实现

// 二分查找的递归实现
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、变体一：查找第一个值等于给定值的元素

有序数据集合中存在重复的数据，希望找到第一个值等于给定值的数据：

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;       //如果中间位置的值大于value，则继续遍历左边
    } else if (a[mid] < value) {
      low = mid + 1;       //如果中间位置的值小于value，则继续遍历右边
    } else {
        if ((mid == 0) || (a[mid - 1] != value)) {
            return mid;  //如果已经找到且此时mid为最左边元素或者mid的左边元素不为value
        else{
            high = mid - 1; //虽然已经找到，但左边的元素也为value
        }
    }
  }
  return -1;
}

代码逻辑：a[mid]跟要查找的 value 的大小关系有三种情况：大于、小于、等于。对于 a[mid]>value 的情况，我们需要更新 high= mid-1；对于 a[mid]<value 的情况，我们需要更新 low=mid+1。这两点都很好理解。那当 a[mid]=value 的时候应该如何处理呢？如果我们查找的是任意一个值等于给定值的元素，当 a[mid]等于要查找的值时，a[mid]就是我们要找的元素。但是，如果我们求解的是第一个值等于给定值的元素，当 a[mid]等于要查找的值时，我们就需要确认一下这个 a[mid]是不是第一个值等于给定值的元素。我们重点看第 11 行代码。如果 mid 等于 0，那这个元素已经是数组的第一个元素，那它肯定是我们要找的；如果 mid 不等于 0，但 a[mid]的前一个元素 a[mid-1]不等于 value，那也说明 a[mid]就是我们要找的第一个值等于给定值的元素。如果经过检查之后发现 a[mid]前面的一个元素 a[mid-1]也等于 value，那说明此时的 a[mid]肯定不是我们要查找的第一个值等于给定值的元素。那我们就更新 high=mid-1，因为要找的元素肯定出现在[low, mid-1]之间。

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

有序数据集合中存在重复的数据，希望查找最后一个值等于给定值的元素：

代码实现逻辑可以参考上面讲解。

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;    //如果中间位置的值大于value，则继续遍历左边
    } else if (a[mid] < value) {
      low = mid + 1;     //如果中间位置的值小于value，则继续遍历右边
    } else {
        if ((mid == n - 1) || (a[mid + 1] != value)) {
            return mid; //如果已经找到value，且到达最右边或者其右边元素不为value
        }
        else{
            low = mid + 1;//如果已经找到value，但其右边元素也为value    
        }
    }
  }
  return -1;
}

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

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) {  //如果中间元素大于value
        if ((mid == 0) || (a[mid - 1] < value)){
            return mid; //如果已经到达最左边或者左边元素小于value，满足条件
        }
        else{
            high = mid - 1; //左边元素依然大于value，继续遍历
        }
    } else {
      low = mid + 1; //继续遍历右边元素
    }
  }
  return -1;
}

代码逻辑：如果 a[mid]小于要查找的值 value，那要查找的值肯定在[mid+1, high]之间，所以，我们更新 low=mid+1。对于 a[mid]大于等于给定值 value 的情况，我们要先看下这个 a[mid]是不是我们要找的第一个值大于等于给定值的元素。如果 a[mid]前面已经没有元素，或者前面一个元素小于要查找的值 value，那 a[mid]就是我们要找的元素。如果 a[mid-1]也大于等于要查找的值 value，那说明要查找的元素在[low, mid-1]之间，所以，我们将 high 更新为 mid-1。

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

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) {  //如果中间元素大于value，继续遍历左边元素
      high = mid - 1; 
    } else {
        if ((mid == n - 1) || (a[mid + 1] > value)){
            return mid;//如果已经到达最右边或者右边的元素大于value，满足条件
        }
        else {
            low = mid + 1; //继续遍历右边元素
        }
    }
  }
  return -1;
}