
int binarySearch(vector<int> &nums, int target) {
    //初始化区间
    int left = 0, right = nums.size() - 1;
    while (left <= right) 
   {
        //小细节：为什么不直接用（left+right）/2
        //这就涉及到程序执行先后顺序的问题了
        //直接先i+j的话有可能发生整数溢出的问题
        //而下面这种方法便可巧妙地一定程度上规避这种问题
        int mid = left + (right - left) / 2; 
        if (nums[mid] < target)   
            left = mid + 1;
        else if (nums[mid] > target) 
            right = mid - 1;
        else 
            return mid;
    }
    // 未找到目标元素，返回 -1
    return -1;
}

因为是双闭区间，左右边界的值都可以取到，所以我们在取左右边界值时分别取它可以取到的最小和最大值，即left = 0, right = nums.size() - 1;
因为是双闭区间，左右边界的值都可以取到，所以我们在缩小边界时左右边界都要进行移动

1.当target>nums[mid]时，说明target在[mid+1,right]上，因此left=mid+1；

2.当target<nums[mid]时，说明target在[left,mid-1]上，因此right=mid-1;

3.当target=nums[mid]时，说明已找到，返回target；

为什么时left<=right？

同样，还是因为它是双闭区间，left=right时也可以存在区间[left,right]

看到这里可能还是理解的不太深刻，看接下来这个对比例子就明白了

2、左闭右开区间


int binarySearch(vector<int> &nums, int target) {
    //初始化区间
    int left = 0, right = nums.size();
    while (left < right) 
   {
        //小细节：为什么不直接用（left+right）/2
        //这就涉及到程序执行先后顺序的问题了
        //直接先i+j的话有可能发生整数溢出的问题
        //而下面这种方法便可巧妙地一定程度上规避这种问题
        int mid = left + (right - left) / 2; 
        if (nums[mid] < target)   
            left = mid + 1;
        else if (nums[mid] > target) 
            right = mid ;
        else 
            return mid;
    }
    // 未找到目标元素，返回 -1
    return -1;
}

因为左闭右开，右边界的值不能确切取到，所以在设置right时要+1
同样，还是因为左闭右开，右边界的值不能确切取到，所以在缩小区间时，right不用-1，反正它也取不到，直接等于mid即可，其实仔细想想效果是一样的
同样，还还是因为左闭右开，右边界的值不能确切取到，所以left=right时不可能存在区间[left,right)，自然也就无法继续了，故循环条件为left<right而没有=

根据上面的对比分析，我们可以发现，它的细节其实原理非常简单，一切细节的设计都是围绕区间的开闭展开，不过要特别说明的是，我们通常更习惯的是采用左闭右闭的双闭区间形式，这样左右都是对称操作的，更不容易出错。

本文下面提到的算法均采用双闭区间的形式。

二、寻找左侧边界（最大值最小化or在单调序列中找x或其前驱）


int binarySearchInsertion(vector<int> &nums, int target) {
    int l = 0, r = nums.size() - 1; 
    while (l <= r) {
        int m = l + (r - l) / 2;
        if (nums[m] < target) {
            l = m + 1;
        } else if (nums[m] > target) {
            r = m - 1; 
        } else {
            l = m - 1; 
        }
    }
    return l;
}

当target>nums[m]或target<nums[m]时，说明还没有找到target，因此仍采用普通二分区间的缩小区间操作，使指针l和r向target靠近
当nums[m]==target时，使r向小于target的元素靠近，因此用r=m-1来缩小区间（因为此处是寻找左侧边界，所以缩小边界时向左缩小）
循环结束后，l指向最左边的target，r指向首个小于target的元素，所以l就是我们的左侧边界

不难发现，二分查找无非就是给指针i和j分别设定搜索目标，在不断的循环二分中，让l和r都逐渐逼近预先设定的目标，总的来说就是一个不断向目标奔赴的过程。

三、寻找右侧边界（最小值最大化or在单调序列中找x或其后继）


int binarySearchInsertion(vector<int> &nums, int target) {
    int l = 0, r = nums.size() - 1; 
    while (l <= r) {
        int m = l + (r - l) / 2;
        if (nums[m] < target) {
            l = m + 1;
        } else if (nums[m] > target) {
            r = m - 1; 
        } else {
            l = m +1; 
        }
    }
    return r;
}