二分查找算法

基本二分查找

二分查找算法(Binary Search)是一种高效的、应用广泛的查找算法。它是一种采用分治策略的算法。

二分查找是针对顺序存储的有序序列的；二分查找的基本思想是：将目标元素与序列中位数比较，如果大于中位数则在右半段序列查找，反之在左半段查找。

为了能够方便表示（以升序序列为例），设置两个索引值start,end表示查找范围即下图中的两个灰色箭头，设置一个标记mid表示当前范围的中间位置,存在且仅存在如下三种情况：

如果values[mid]==target,则return mid
如果values[mid]<target,则start=mid+1
如果values[mid]>target,则end=mid-1;

例如一组元素values[2,3,5,12,23,24,25,26,27]，查找目标target=26的过程如下图所示：

二分查找之所以快速是因为：相对于序列长度而言，它只需要检查很少几个条目就能找到目标元素或者是确定目标元素不存在。

二分查找的思想还是很简单的，具体实现如下：

public static int binarySearch(int[] values,int target){
    if(values==null){
        throw new NullPointerException("values==null");
    }
    boolean asc=values[0]<values[values.length-1]?true:false;
    int start=0;
    int end=values.length-1;
    while(start <= end){
        int mid=start+(end-start)/2;
        if(target==values[mid]) {
            return mid;
        }else if(target<values[mid]){
            if(asc){
                end=mid-1;
            }else{
                start=mid+1;
            }
        }else{
            if(asc){
                start=mid+1;
            }else{
                end=mid-1;
            }
        }
    }
    return -1;
}

旋转数组的二分查找

下面讨论一下旋转数组的二分查找算法；

旋转有序数组也是一个有序序列，只不过它是错位的，比如下面的两个序列都是旋转有序数组，旋转数组中存在一个旋转点，升序下的旋转点就是最小元素，而降序下旋转点是最大元素。

对于旋转数组的二分查找，可以分以下两种情况讨论，一是已知旋转点的位置，二是未知旋转点位置。

已知旋转点

如果已经直到旋转点的位置rotatedPoint，问题瞬间变得简单，算法思路和基本二分查找算法一致；

唯一改变的是需要一个映射公式：j=(rotatedPoint+i)%values.length。其中i表示下标（即算法中的mid等）,j表示实际引用元素的下标。该公式在升序降序下都成立。

根据这个公式，只需要对基本的算法略加改进即可（实际上只需要改变mid，因为二分查找只会在mid处进行比较）：

注意：由于不是严格排序的，不能再使用values[0]<values[values.length-1]?true:false条件判断是否是升序，可以改为values[rotatedPoint]<values[values.length-1]?true:false;

public static int rotatedBinarySearch(int[] values,int target,int rotatedPoint){
    if(values==null){
        throw new NullPointerException("values==null");
    }
    boolean asc=values[rotatedPoint]<values[values.length-1]?true:false;
    int start=0;
    int end=values.length-1;
    while (start<=end){
        int mid=start+(end-start)/2;
        int map=binarySearchIndexMap(mid,values.length,rotatedPoint);
        if(values[map]==target) {
            return map;
        }else if(values[map]<target){
            if(asc){
                start=mid+1;
            }else {
                end=mid-1;
            }

        }else{
            if(asc){
                end=mid-1;
            }else {
                start=mid+1;
            }
        }
    }
    return -1;
}

private static int binarySearchIndexMap(int index,int length,int rotatedPoint){
    return (rotatedPoint+index)%length;
}

未知旋转点

未知旋转点的情况比较复杂，以升序序列为例；

同样需要判断目标在左半边还是右半边，只不过无法直接判断，这与中位数和旋转点的位置相关，所以首先要判断旋转点和中位数的位置关系。

如果旋转点在中位数的右侧，应该由values[start]<=values[mid]判断出来，中位数在左侧就是!( values[start]<=values[mid]);

旋转点在中位数右侧时，如果目标在左半边的话，由于左半边是完全升序的;

所以判断条件应该是：values[start]<=target<values[mid]，在左半边就是!( values[start]<=target<values[mid]);

旋转点在中位数左侧时，如果目标在右半边的话，由于右半边是升序的，所以判断条件应该是：values[mid]<target<=values[end],在左半边取反即可。

对于降序而言，进行同样的分析，可以得到完整的判断条件：

根据以上条件，修改二分查找算法代码实现：

public static int rotatedBinarySearch(int[] values,int target,boolean asc){
    if(values==null){
        throw new NullPointerException("values==null");
    }
    int start=0;
    int end=values.length-1;
    while(start<=end){
        int mid=start+(end-start)/2;
        if(values[mid]==target){
            return mid;
        }else {
            if(asc){  //升序排列
                if(values[mid]>=values[start]){
                    if(values[mid]>target&&values[start]<=target){
                        end=mid-1;
                    }else {
                        start=mid+1;
                    }
                }else {
                    if(values[mid]<target&&values[end]>=target){
                        start=mid+1;
                    }else {
                        end=mid-1;
                    }
                }
            }else {
                if(values[mid]>=values[end]){
                    if(values[mid]>target&&values[end]<=target){
                        start=mid+1;
                    }else{
                        end=mid-1;
                    }
                }else{
                    if(values[mid]<target&&values[start]>=target){
                        end=mid-1;
                    }else{
                        start=mid+1;
                    }
                }
            }
        }
    }
    return -1;
}

二分查找的溢出风险

在代码中mid=start+(end-start)/2，而没有写为mid=(start+end)/2是因为(start+end)/2可能存在溢出的威胁：如果数组很长，start和end可以会非常大，start+end会变得更大,可能超过了int的最大范围。所以改写为mid=start+(end-start)/2;

（旋转数组）二分查找