折半查找练习

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

时间复杂度：O(logn)

    数据大小为n的数组，每次只比较中间的值，然后数据规模缩小n/2，最坏的情况也就是一直到查找空间为空的时候，假设k次比对即可找到正确值，（查到空间为空时）n/(2^k)=1，则k=k=log2n，时间复杂度也就是O(logn)。
    时间复杂度为O(logn)：假设一个数组的数据大小n为 2^32，大约是四十多亿，用二分查找来查找里面的一个数的话，最多比较32次也就可以得到这个值了,非常恐怖的快。
 

时间复杂度为O(logn)是在使用数组存储数据的情况下，因为折半查找可以通过下标直接访问中间的二分元素，如果使用链表存储数据呢？使用折半查找的时间复杂度是多少？
答案是O(n)，而且甚至可能比遍历查找还慢一些（因为遍历的操作比对命令行更少）。
因为每一次找到中间节点然后比对必须从头开始遍历，比对k次的时间也就是T(n/2)+T(n/4)+…T(n/2^k) = T(n-1)【我也不知道我求错没有】，总之基本上就是O(n)的时间复杂度了。
 
折半查找的使用局限：\

1. 仅能适用于数组结构，并且数组必须是有序数组，否则需要给数组再排序，就算是快排也需要再使用O(nlogn)的时间。需要连续的内存空间来存储数据，理由如上，因为需要使用数组结构存储数据。
2. 尽量在静态数据中使用，因为动态数据很难保持长时间的有序，那样排序会给算法带来很大的负担。动态查找需要使用其他的查找算法。
3. 数据量不能太小，较小的数据量中时间复杂度和遍历基本无区别，而太大的数据又无法保证有序和连续的存储空间。

 

// 循环实现
function bsearch (a,k) {
  let mid,low = 0,high = a.length-1;
  while(low <= high){
    mid = Math.floor((low + high)/2);
    if(a[mid] === k) {
      return mid
    }else if(a[mid]<k){
      low = mid + 1;
    }else{
      high = mid - 1;
    }
  }
  return -1;
}

// 递归实现
function bsearch (a,k,low,high) {
  if(!low) {low = 0; high = a.length-1;};
  if(low > high) return -1;
  const mid = Math.floor((low + high)/2);
  if(a[mid] === k) {
    return mid;
  }else if(a[mid] < k){
    return bsearch(a,k,mid+1,high)
  }else{
    return bsearch(a,k,low,mid-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，就会导致一直循环不退出。

---

二分查找的变形问题

上文所写的二分查找是最基础的一种，数组中没有重复数据并且已排序。

 

 

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

function bsearch (a,k) {
  let mid,low = 0,high = a.length-1;
  while(low <= high){
    mid = Math.floor((low + high)/2);
    if(a[mid] === k) {
      // 判断是不是当前数组里第一个等于k的元素
      if(mid === 0 || a[mid-1] !== a[mid]){
        return mid;
      }else{
        high = mid - 1;
      }
    }else if(a[mid]<k){
      low = mid + 1;
    }else{
      high = mid - 1;
    }
  }
  return -1;
}

 

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

function bsearch (a,k) {
  let mid,low = 0,high = a.length-1;
  while(low <= high){
    mid = Math.floor((low + high)/2);
    if(a[mid] === k) {
      // 判断是不是当前数组里第一个等于k的元素
      if(mid === a.length-1 || a[mid+1] !== k){
        return mid;
      }else{
        high = mid - 1;
      }
    }else if(a[mid]<k){
      low = mid + 1;
    }else{
      high = mid - 1;
    }
  }
  return -1;
}

 

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

function bsearch (a,k) {
  let mid,low = 0,high = a.length-1;
  while(low <= high){
    mid = Math.floor((low + high)/2);
    if(a[mid]<k){
      low = mid + 1;
    }else{
      if(mid === 0 || a[mid - 1] < k){
        return mid;
      }
      high = mid - 1;
    }
  }
  return -1;
}

 

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

function bsearch (a,k) {
  let mid,low = 0,high = a.length-1;
  while(low <= high){
    mid = Math.floor((low + high)/2);
    if(a[mid]<=k){
      if(mid === a.length-1 || a[mid + 1] > k){
        return mid;
      }
      low = mid + 1;
    }else{
      high = mid - 1;
    }
  }
  return -1;
}

 

5、查找最后一个大于等于给定值的元素

function bsearch (a,k) {
  let mid,low = 0,high = a.length-1;
  while(low <= high){
    mid = Math.floor((low + high)/2);
    if(a[mid]<k){
      low = mid + 1;
    }else{
      if(mid === a.length-1 || (a[mid + 1] > k && a[mid - 1] <= k )){
        return mid;
      }
      high = mid - 1;
    }
  }
  return -1;
}

 

扩展题：剑指 Offer II 072. 求平方根

给定一个非负整数 x ，计算并返回 x 的平方根，即实现 int sqrt(int x) 函数。
正数的平方根有两个，只输出其中的正数平方根。
如果平方根不是整数，输出只保留整数的部分，小数部分将被舍去。

var mySqrt = function(x) {
    let mid=0,low = 0,high = x;
    if(x === 0 || x === 1) return x
    while(low <= high){
        mid = low + Math.floor((high-low)/2);
        if(x/mid === mid){
            return Math.floor(mid);
        }else if(x/mid > mid){
            low = mid + 1;
        }else{
            high = mid - 1;
        }
    }
    return Math.floor(low * low < x ? low : low-1); // 向下取整，取low而非mid ，代入数据1即可知
};