二分查找算法题（折半查找）

1.寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

题解：

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
       double s=1.0;
        int a=nums1.length+nums2.length;
        int b=a/2;
        int[] arr=new int[a];
        for(int i=0;i<nums1.length;i++){
           arr[i]=nums1[i];
        }
        for (int i = 0; i < nums2.length; i++) {
          arr[nums1.length+i]=nums2[i];
        }
        Arrays.sort(arr);
        if(a%2==0){
            s=(arr[b-1]+arr[b])/2.0;
        }else {
            s=arr[b];
        }
        return s;
    }
}

2.在排序数组中查找元素的第一个和最后一个位置 

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

题解：这道题的重点是在查找到对应的目标值时，无论从左还是从右查找，找到目标之以后仍然要继续之前的扫描方向，直到不是目标值为止，这样才能找到目标值的起始和结束位置

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if (nums.length == 0 || nums[0] > target || nums[nums.length - 1] < target) {
            return new int[] {-1,-1};
        }
        int lm = leftMargin(nums,target);
        int rm = rightMargin(nums,target);
        return new int[] {lm,rm};
    }
        public int leftMargin(int[] nums,int target){
        int low = 0;
        int high = nums.length - 1;
        while(low <= high){
            int mid = low + (high-low)/2;
            if(nums[mid] < target){
                low = mid + 1;
            }else if(nums[mid] > target){
                high = mid - 1;
            }else if(nums[mid] == target){
                high = mid - 1;//重点所在
            }
        }
        if (nums[low] == target) {
            return low;
        } else {
            return -1;
        }
    }
    public int rightMargin(int[] nums,int target){
        int low = 0;
        int high = nums.length - 1;
        int rm = -2;
        while(low <= high){
            int mid = low + (high-low)/2;
            if(nums[mid] < target){
                low = mid + 1;
            }else if(nums[mid] > target){
                high = mid - 1;
            }else if(nums[mid] == target){
                low = mid + 1;//重点所在
                rm = low;
            }
        }
        if (nums[high] == target) {
            return high;
        } else {
            return -1;
        }
    }
}

 3.x 的平方根​​​​​​ 

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

题解：

class Solution {
    public int mySqrt(int x) {
    int left = 0, right = x, ans = 0;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if ((long) mid * mid <= x) {
                ans = mid;
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return ans;
    }
}

4.搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

题解:将一个数组转化为两个有序数组，再在两个有序数组中进行查找

class Solution {
    public int search(int[] nums, int target) {
        int mid = 0;
        for( int i = 0; i < nums.length-1; i++){
            if(!(nums[i] < nums[i + 1])){
                mid = i;
            }
        }
       if(target >= nums[0] && target <= nums[mid]){
           return leftIndex(nums, mid, target);
       }else return rightIndex(nums, mid, target);
    }
    public int leftIndex(int[] nums, int mid, int target){
        int left = 0;
        int right = mid;
        while(left <= right){
            int ban = (left + right) / 2;
            if(target > nums[ban]){
                left = ban + 1;
            }else if(target < nums[ban]){
                right = ban - 1;
            }else return ban;
        }
        return -1;
    }

    public int rightIndex(int[] nums, int mid, int target){
        int left = mid + 1;
        int right = nums.length - 1;
        while(left <= right){
            int ban = (left + right) / 2;
            if(target > nums[ban]){
                left = ban + 1;
            }else if(target < nums[ban]){
                right = ban - 1;
            }else return ban;
    }  
    return -1;
}
}

注：以上算法题中进行折半时建议使用右移运算符向右移动一位（这样能够很好的规避数据溢出的问题