二分法——一文学会如何确定边界

1.二分查找基本概述

• 二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。
• 二分法有「整数二分」和「实数二分」两种情况。实数二分的代码好写不易出错；整数二分的代码因为要考虑整除的问题，代码容易出错。
• 二分法很容易出错。要找清楚答案在哪，区间在哪。
• 二分查找最多查找$\lceil lo{g}_2(n)\rceil$次
• 二分查找最少查找1次

2.二分查找实现原理

假设我们比较的有序数列有三个数,我们比较一个元素的值和数组中间位置的元素的值进行比较,如果比中间的元素大,则在有序数组的后半部分进行查找;如果中间位置的元素的值小,则跟有序数组的前半部分进行比较;如果相等,则找到了比较元素的位置.

3.二分查找边界选择

二分查找边界的选择一般有两种情况。对于ls = {n,n,n,n,n,…,n};

• 第一种：$l=0,r=ls.length$——左闭右开
  下面代码里有详细总结
• 第二种：$l=0,r=ls.length-1$——左闭右闭
  下面代码里有详细总结

4.代码——详细注解

public class BinarySearch {


    public static void main(String[] args) {
        int arry[] = {51, 53, 54, 55,55,55, 58, 64, 76};
//        System.out.println(binarySearch(arry,51));
        System.out.println(binarySearch4(arry,55));

        
    }



    /**
     * @D:查找一个数组，找得到返回索引。找不到返回-1
     * @param array
     * @param target
     * @return
     */
    public static int binarySearch(int array[],int target){
        int l = 0 ;
        int r = array.length-1;

        while (l<=r){
            int mid = (l+r)/2;
            if (array[mid]>target) {
                r = mid-1;
            }else if(array[mid]<target){
                l = mid+1;
            }else{
                return mid;
            }
        }
        return -1;
    }



    /*----------------------------------------------左闭右闭进行二分查找--------------------------------------------------- */


    /*
    代码总结：
        对于左开右闭的区间，有如下规律：
        	条件：r<=l
            前继代码：
            if(array[mid]<=target)
                ans = mid;
                r = mid-1;
            else:
                l = mid+1;

            后继代码：
            if(array[mid]<=target)
                ans = mid;
                l = mid+1;
            else:
                r = mid-1;
        l、r的选择，要么加1 要么减1.
     */


    /**
     * @D:如果没有这个元素，返回大于target第一个元素的下标（target的后继）（大于target的最小值）；如果有多个相同的元素，那么返回第一个元素的下标；如果超过最大元素的值返回0
     * @param array
     * @param target
     * @return
     */
    public static int binarySearch1(int array[],int target){
        int l = 0;
        int r = array.length-1;
        int ans = 0;
        while (l<=r){
            int mid = (l+r)>>1;
            if (array[mid]>=target){
                ans = mid;
                r = mid-1;
            }else{
                l = mid+1;
            }
        }
        return ans;
    }



    /**
     * @D:如果没有这个元素，返回小于target的第一个元素的下标（前继代码）（小于target的最大值）；如果存在多个相同的，返回最后一个元素的下标
     * @param array
     * @param target
     * @return
     */
    public static int binarySearch2(int array[],int target){
        int l = 0;
        int r = array.length-1;
        int ans = 0;
        while (l<=r){
            int mid = (l+r)>>1;
            if (array[mid]<=target){
                ans = mid;
                l = mid+1;
            }else{
                r = mid-1;
            }
        }
        return ans;
    }


    /*----------------------------------------------左闭右开进行二分查找--------------------------------------------------- */


    /*
    代码总结：
        对于左闭右开的区间，有如下规律：
        	条件：r<l
            r（大的一端）始终等于mid
            l用控制是否加1 或者 减1
     */





    /**
     * @D:后继代码；
     * @param array
     * @param target
     * @return
     */
    public static int binarySearch3(int array[],int target){
        int l = 0;
        int r = array.length;
        int ans = 0;
        while (l<r){
            int mid = (l+r)>>1;
            if (array[mid]>=target){
                ans = mid;
                r = mid;
            }else{
                l = mid+1;
            }
        }
        return ans;
    }


    /**
     * @D:前继代码
     * @param array
     * @param target
     * @return
     */

    public static int binarySearch4(int array[],int target){
        int l = 0;
        int r = array.length;
        int ans = 0;
        while (l<r){
            int mid = (l+r)>>1;
            if (array[mid]<=target){
                ans = mid;
                l = mid+1;
            }else{
                r = mid;
            }
        }
        return ans;
    }
}