二分查找算法

二分查找

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

二分查找的递归与非递归实现

非递归实现

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,而不是low<high；
   2.mid的取值：实际上，mid=(low+high)/2 这种写法是有问题的。因为如果 low 和 high 比较大的话，两者之和就有可能会溢出。改进的方法是将 mid 的计算方式写成 low+(high-low)/2。更进一步，如果要将性能优化到极致的话，我们可以将这里的除以 2 操作转化成位运算 low+((high-low)>>1)。因为相比除法运算来说，计算机处理位运算要快得多。
   3.low和high的更新： low=mid+1，high=mid-1。注意这里的 +1 和 -1，如果直接写成 low=mid 或者 high=mid，就可能会发生死循环。比如，当 high=3，low=3 时，如果 a[3]不等于 value，就会导致一直循环不退出。

递归实现

// 二分查找的递归实现
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);//注意不能写成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.数据量太小不适合二分查找，数据量太大也不适合二分查找

二分查找算法题

1 求平方根

给定一个非负整数 x ，计算并返回 x 的平方根，即实现 int sqrt(int x) 函数。
正数的平方根有两个，只输出其中的正数平方根。
如果平方根不是整数，输出只保留整数的部分，小数部分将被舍去。
思路：二分查找，注意不要溢出，所以后面mid*mid 强转成long类型

 public int mySqrt(int x) {
   
        int left =0,right = x; 
        int mid = 0; 
        while(left <= right){
   
            mid = left+(right-left)/2;
            if((long)mid*mid<=x && (long)(mid+1)*(mid+1)>x){
   
                return mid;
            }else if((long)mid*mid < x){
   
                left = mid+1;
            }else{
   
                right = mid-1;
            }
        }
        return mid;
    }

2.求一个数的平方根，保留6位小数

需要考虑特殊情况，当x大于0小于1的情况，此时left和right需要交换，此处没有变

  public double sqrts(double x ,double per){
   
        double left=0,right = x;
        while(left<= right){
   
            double mid = left+(right-left)/2;
            System.out.println(mid);
            if(Math.abs(mid*mid-x)<=per){
   
                return mid;
            }else if(mid*mid >x){
   
                right = mid;//-0.00001;
            }else {
   
                left = mid;//+0.00001;
            }
        }//2.82842724685669
        return -1;
    }

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

思路：最简单的思路就是先查到该值后，然后在向前一个个的遍历，直到为0或者前面的一个数不等于要找的target为止，这种效率低，对于数据量少的还可以，对于数据量大的数组来说，效率低
进阶思路，在二分查找中进行。

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