自己写的二分查找模板

存在三种基本模式:

1. 标准二分查找

2. 二分查找左边界

3. 二分查找右边界

 

• 只有第1种情况能够在循环内部返回.
• 这种标准二分查找是左闭右开的写法. 查找范围是 l <= n < r
• 中间位置计算时, m = (l+r)/2, 这样得到的中间位置靠左.  m = (l+r)/2 +1, 这样得到的中间位置靠右.
• 其中, 2.3两种情况下, 左边界和右边界分别需要逐渐的缩小, 不然会造成边界丢失. 

class Solution {
        public int BiSearch(int[] nums, int a)//标准二分查找, 左闭右开
        {
            int r = nums.length;
            int l = 0;
            while(l < r)
            {
                int m = (l+r)/2;
                if(nums[m] == a) return m;
                else if(nums[m] < a) l = m+1;
                else r = m;
            }
            return -1;
        }
        public int leftBiSearch(int[] nums, int a)//二分查找左边界, 需要逐渐缩小左边界范围,两端都闭
        {
            int l = 0;
            int r = nums.length-1;
            int m = 0;
            while(l < r)
            {
                m = (l+r)/2;
                if(nums[m] < a) 
                    l = m+1;
                else 
                    r = m;
            }
            return nums[l] == a? l: -1;
        }

        public int rightBisearch(int[] nums, int a)//二分查找右边界, 需要逐渐缩小右边界范围,两端都闭
        {
            int l = 0;
            int r = nums.length-1;
            int m = 0;
            while(l < r)
            {
                m = (l+r)/2 +1;
                if(nums[m] > a)
                    r = m-1;
                else 
                    l = m;
            }
            return nums[r] == a? r: -1;
        }
}

二分查找练习题目列表：

1. 给定一个有序（非降序）数组A，求任意一个i使得A[i]等于target，不存在则返回-1
2. 给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]等于target，不存在则返回-1
3. 给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]等于target，不存在则返回-1
4. 给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]小于target，不存在则返回-1
5. 给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]大于target，不存在则返回-1
6. 给定一个有序（非降序）数组A，可含有重复元素，求target在数组中出现的次数。
7. 给定一个有序（非降序）数组A，若target在数组中出现，返回位置，若不存在，返回它应该插入的位置。
8. 给定一个有序（非降序）数组A，可含有重复元素，求绝对值最小的元素的位置
9. 给定一个有序（非降序）数组A和一个有序（非降序）数组B，可含有重复元素，求两个数组合并结果中的第k(k>=0)个数字。
10. 一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求target在变化后的数组中出现的位置，不存在则返回-1.
11. 一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求最小值所在位置
12. 一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求第k(k > 0)小元素