二分查找

  最近在做leetcode的题目的时候经常回用到二分查找相关的操作，于是在此总结一下，供日后复习之用。条件中的数组默认为从小到大排序。

基本的二分查找

  给定一个有序的数组，查找数组中特定的元素并返回其索引，如果不存在，则返回-1。代码如下:

    public static int binary_search(List<Integer> list,int key){
        int l=0,r=list.size()-1;
        while(l<=r){
            int m=l+(r-l)/2;
            if(list.get(m)==key){
                return m;
            }
            else if(list.get(m)<key){
                l=m+1;
            }
            else{
                r=m-1;
            }
        }
        return -1;
    }

当有多个目标元素时，会返回其中某一个元素的下标。

查找第一个等于目标值的元素

  给定一个有序的数组，查找数组中第一个等于目标值的元素并返回其索引，如果不存在，则返回-1。代码如下:

    public static int binary_search(List<Integer> list,int key){
        int l=0,r=list.size()-1;
        while(l<=r){
            int m=l+(r-l)/2;
            if(list.get(l)==key){
                return l;
            }
            else if(list.get(m)>=key){
                r=m-1; 
            }
            else{
                l=m+1;
            }
        }
        return -1;
    }

查找最后一个等于目标值的元素

  给定一个有序的数组，查找数组中最后一个等于目标值的元素并返回其索引，如果不存在，则返回-1。代码如下:

   public static int binary_search(List<Integer> list,int key){
        int l=0,r=list.size()-1;
        while(l<=r){
            int m=l+(r-l)/2;
            if(list.get(r)==key){
                return r;
            }
            else if(list.get(m)<=key){
                l=m+1;
            }
            else{
                r=m-1;
            }
        }
        return -1;
    }

查找第一个大于或等于目标值的元素

  给定一个有序数组，查找数组中第一个大于或等于目标值的元素并返回其索引。

   public static int binary_search(List<Integer> res,int key){
        if(res.size()==0){
            return -1;
        }
        if(res.get(res.size()-1)<key){
            return -1;
        }
        if(res.get(0)>=key)
            return 0;
        int l=0,r=res.size()-1;
        while(r-l>1){
            int m=l+(r-l)/2;
            if(res.get(m)<key){
                l=m;
            }
            else{
                r=m;
            }
        }
        return r;
    }

这和STL中的lower_bound的作用是一样的。

查找第一个大于目标值的元素

  给定一个有序数组，查找第一个大于目标值的元素并返回索引。
代码如下：

    public static int binary_search(List<Integer> res,int key){
        if(res.size()==0){
            return -1;
        }
        if(res.get(res.size()-1)<=key){
            return -1;
        }
        if(res.get(0)>key)
            return 0;
        int l=0,r=res.size()-1;
        while(r-l>1){
            int m=l+(r-l)/2;
            if(res.get(m)<=key){
                l=m;
            }
            else{
                r=m;
            }
        }
        return r;
    }

这和STL中的upper_bound的作用是一样的。

对于小于及小于等于的情况，和以上情况中的四和五是类似的，不再赘述。
参考资料¹

---

1. https://www.geeksforgeeks.org/binary-search/ ↩︎