二分查找（上）：如何用最省内存的方式实现快速查找功能？

二分查找（上）：如何用最省内存的方式实现快速查找功能？

针对有序数据集合的查找算法：二分查找算法也叫折半查找算法

假设我们有1000W个整数数据，每个数据占8个字节，如何设计数据结构和算法，快速判断某个整数是否出现在这1000W数据中?最后不要占用太多的内存空间，不要超过100M？

假设我们要猜测0-99之间的数据，你来猜写的什么数字，如果是23（如果猜测范围的数字有偶数个，中间数有两个，就选择较小的那个）

次数	猜测范围	中间数	对比大小
第一次	0-99	49	49 > 23
第二次	0-48	24	24 > 23
第三次	0-23	11	11 < 23
第四次	12-23	17	17 <23
第五次	18-23	20	20 < 23
第六次	21-23	22	22 < 23
第七次	23		√

假设有1000个订单金额，已经按照从小到大排序，现在想知道有没有=19的订单，如何存在，返回订单数据，不存在返回null

订单金额分别为8,11,19,23,27,33,45,55,67,98，low和high表示待查找区间的下标，mid表示待查找区间的中间元素下标，第一次：low = 8 ,mid = 27,high = 98,第二次 : low = 8 ,mid = 11,high = 23,第三次：low =19 , mid = 19 , high = 23

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

三个容易出错的3个地方：

1.循环退出条件

是low <= high，而不是low < high

2.mid的取值

mid = (low+high) / 2有问题，如果low 和high比较大，它们的和可能会溢出，改进的方法是low+(high-low)/2,如果将性能优化到极致的话，将除以2转化为位运算low+(high-low)>>1，计算机处理位运算更快

3.low和high的更新

low = mid + 1 ，high = mid -1若是直接写成low = mid，high = mid 可能发生死循环

实际上二分查找除了用循环来实现，还可以用递归来实现

//二分查找的递归实现
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);
  }
}

二分查找应用场景的局限性

首先，二分查找依赖的是顺序表的结构，就是数组

二分查找算法需要按照下标随机访问元素

然后二分查找针对的是有序数据

二分查找只能用在插入、删除操作不频繁，一次排序多次查找的场景中。针对动态数据集合，二分查找不再适用

再次，数据量太小也不适合二分查找

数据量很小，顺序遍历就足够了，只有数据量很大的时候二分查找的优势才会显示出来，但是如果数据之间的比较操作非常耗时，不管数据量大小，都推荐二分查找

最后，数据量太大也不适合二分查找

二分查找的底层需要依赖数组这种数据结构，数组为了支持随机访问的特性，要求内存空间连续，对内存的要求比较苛刻

如何在1000W个整数中快速查找某个整数？

内存限制是100MB，每个数据的大小是8B，最简单的方法是将数据存储在数组中，内存占用是80MB，符合内存的限制，可以先对这1000W个数据进行排序，再利用二分查找算法，可以快速查找数据

大部分情况下，用二分查找可以解决的问题，用散列表、二叉树都可以解决，但是不管是散列表还是二叉树都会需要比较多的额外空间，而二分查找底层依赖的是数组，除了数据本身之外，不需要额外存储其他信息，是最省内存空间的存储方式，所以刚好在限定的内存大小解决这个问题

如何编程实现“求一个数的平方根”？要求精确到小数点后6位

public static double sqrt(double x, double precision){   //数值和精确值
  if (x < 0){
    return Double.Nan;
  }
  
  double  low = 0;
  double up = x ;
  if(x < 1 && x> 0){   //小于1的时候
    low = x;
    up =1;
  }
  double mid = low+(up-low)/2;
  while(up-low > precision){
    if(mid > x/mid){
    up = mid;
    }else if (mid < x/mid){
      low = mid;
    }else{
      return mid;
    }
    mid = low + (up-low)/2;
  }
  return mid;
}