算法-二分查找

1.在有序数组中查找用二分查找
2.在计算中位数时 不用(left + right) / 2是因为：若left right特别大 left + right可能会溢出 所以用left + (right + left) / 2来代替
3.向下取整不更新右边界会出现死循环，向上取整不更新左边界会出现死循环
4.在计算中位数时建议使用：mid= left + (right - left) >> 1 注意在JS中右移>>1、左移<<1会自动取整 而 / 2不会自动取整 会保护小数 右移运算符>> 左移运算符<< 优先级都低于加减乘除 所以使用时一定要用括号包裹起来

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

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

示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
示例 3：
输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000
示例 4：
输入：nums1 = [], nums2 = [1]
输出：1.00000
示例 5：
输入：nums1 = [2], nums2 = []
输出：2.00000

解：

1. 方法一：两个数组升序合并 返回中位数
2. 方法二：双指针：
   这道题可以转化成寻找两个有序数组中的第k小的数，其中k= (m+n)/2或(m+n)/2-1。
   那么可以定义i j两个指针分别指向nums1[0] nums2[0] 若nums1[0]<nums2[0] 则i++ 若nums1[0]>nums2[0] 则j++ 直到i+j===k 输出结果
3. 方法三：二分查找
   推论：
   假设两个有序数组分别是A 和B。要找到第k个元素，我们可以比较A[k/2−1] 和B[k/2−1]，由于A[k/2−1] 和B[k/2−1] 的前面分别有A[0…k/2−2] 和B[0…k/2−2]，即 k/2-1个元素，对于A[k/2−1] 和B[k/2−1] 中的较小值，最多只会有 (k/2−1)+(k/2−1)≤k−2 个元素比它小，那么它就不能是第k小的数了。因此，如果 A[k/2−1]<B[k/2−1]，则比A[k/2−1] 小的数最多只有k−2 个，因此A[k/2−1] 不可能是第k个数，A[0] 到A[k/2−1] 也都不可能是第k个数，可以全部排除。
   具体做法：

A: 1 3 4 9
B: 1 2 3 4 5 6 7 8 9

两个有序数组A B的长度分别是 4 和 9，长度之和是 13，中位数是两个有序数组中的第 7 个元素，因此需要找到第k=7 个元素。
比较两个有序数组中下标为k/2−1=2 的数，即A[2] 和B[2]，如下面所示：

由于A[2]>B[2]，因此排除B[0] 到B[2]，原来B[3]变为了B[0] 更新k的值 因为已经排除了k/2个数 所以：k=k−k/2=4。此时问题转化为了找第4小的数
比较两个有序数组中下标为k/2−1=1 的数，即A[1] 和B[4]，如下面所示，其中方括号部分表示已经被排除的数。按理说我们应该找移除元素后的B数组的B[1] B[1]就是未删除元素的B的B[4]

由于A[1]<B[4]，因此排除A[0]到A[1]，即数组A 的下标偏移变为 2，原来A[2]变成了A[0] 更新k的值：k=k-k/2=2。此时问题转化为了找第2小的数
比较两个有序数组中下标为k/2−1=0 的数，即比较A[2]和B[3]，如下面所示，其中方括号部分表示已经被排除的数。

由于A[2]=B[3]，排除A 中的元素（也可以排除B中的元素），因此排除A[2]，即数组A 的下标偏移变为 3，同时更新 kk 的值：k=k−k/2=1。此时问题转化为了找最小的数，因此，比较两个有序数组中的未排除下标范围内的第一个数，其中较小的数即为第 kk 数，由于A[3]>B[3]，因此第k个数是B[3]=4。

有以下三种情况需要特殊处理：

1. 如果A[k/2−1] 或者B[k/2−1] 越界，那么我们可以选取对应数组中的最后一个元素。在这种情况下，我们必须根据排除数的个数减少k的值，而不能直接将k减去k/2。
2. 如果一个数组为空，说明该数组中的所有元素都被排除，我们可以直接返回另一个数组中第k小的元素。
3. 如果k=1，我们只要返回两个数组首元素的最小值即可。

代码如下：
JAVA

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int length1 = nums1.length, length2 = nums2.length;
        int totalLength = length1 + length2;
        if (totalLength % 2 == 1) {
            int midIndex = totalLength / 2;
            double median = getKthElement(nums1, nums2, midIndex + 1);
            return median;
        } else {
            int midIndex1 = totalLength / 2 - 1, midIndex2 = totalLength / 2;
            double median = (getKthElement(nums1, nums2, midIndex1 + 1) + getKthElement(nums1, nums2, midIndex2 + 1)) / 2.0;
            return median;
        }
    }

    public int getKthElement(int[] nums1, int[] nums2, int k) {
        /* 主要思路：要找到第 k (k>1) 小的元素，那么就取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较
         * 这里的 "/" 表示整除
         * nums1 中小于等于 pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个
         * nums2 中小于等于 pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个
         * 取 pivot = min(pivot1, pivot2)，两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个
         * 这样 pivot 本身最大也只能是第 k-1 小的元素
         * 如果 pivot = pivot1，那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums1 数组
         * 如果 pivot = pivot2，那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums2 数组
         * 由于我们 "删除" 了一些元素（这些元素都比第 k 小的元素要小），因此需要修改 k 的值，减去删除的数的个数
         */

        int length1 = nums1.length, length2 = nums2.length;
        int index1 = 0, index2 = 0;
        int kthElement = 0;

        while (true) {
            // 边界情况
            if (index1 == length1) {
                return nums2[index2 + k - 1];
            }
            if (index2 == length2) {
                return nums1[index1 + k - 1];
            }
            if (k == 1) {
                return Math.min(nums1[index1], nums2[index2]);
            }
            
            // 正常情况
            int half = k / 2;
            int newIndex1 = Math.min(index1 + half, length1) - 1;
            int newIndex2 = Math.min(index2 + half, length2) - 1;
            int pivot1 = nums1[newIndex1], pivot2 = nums2[newIndex2];
            if (pivot1 <= pivot2) {
                k -= (newIndex1 - index1 + 1);
                index1 = newIndex1 + 1;
            } else {
                k -= (newIndex2 - index2 + 1);
                index2 = newIndex2 + 1;
            }
        }
    }
}

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

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。

示例 1：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]
示例 2：
输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]
示例 3：
输入：nums = [], target = 0
输出：[-1,-1]

解：在有序数组中查找用二分查找
方法以：二分查找【第一个等于target的位置】和【最后一个等于target的位置】

var searchRange = function(nums, target) {
    function search (nums, target, first) {// first=true表示查找第一个等于目标值的下标
        let len = nums.length, low = 0, high = len - 1
        while (low <= high) {
            let mid = low + ((high - low) >> 1)
            if (nums[mid] > target) {
                high = mid - 1
            } else if (nums[mid] < target) {
                low = mid + 1
            } else {
                if (first) {
                    if (mid === 0 || nums[mid - 1] !== target) return mid
                    high = mid - 1    
                } else {
                    if (mid === len - 1 || nums[mid + 1] !== target) return mid
                    low = mid + 1
                }
            }
        }
        return -1
    }
    return [search(nums, target, true), search(nums, target)]
};

方法二：查找【第一个等于target的位置】和【第一个大于target的位置】

class Solution {
    //先找>=target的第一个
    //再找>target的第一个
    public int[] searchRange(int[] nums, int target) {
        int l=search(nums,target);
        int r=search(nums,target+1);
        if(l==nums.length||nums[l]!=target)
            return new int[]{-1,-1};
        return new int[]{l,r-1};
    }
    //找>=target的第一个
    public int search(int[] nums,int target){
        int l=0,r=nums.length;
        while(l<r){
            int mid=(r+l)>>1;
            if(nums[mid]>=target)
                r=mid;
            else
                l=mid+1;
        }
        return l;
    }
}

方法三：查找【最后一个小于target的位置】和【第一个大于target的位置】

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int leftIdx = binarySearch(nums, target - 1);
        int rightIdx = binarySearch(nums, target) - 1;
        if (leftIdx <= rightIdx && nums[leftIdx] == target) {
            return new int[]{leftIdx, rightIdx};
        } 
        return new int[]{-1, -1};
    }

    // 第一个大于 target 的数的下标
    public int binarySearch(int[] nums, int target) {
        int left = 0, right = nums.length - 1, ans = nums.length;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] > target) {
                right = mid - 1;
                ans = mid;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }
}

剑指 Offer 53 - I. 在排序数组中查找数字 I

统计一个数字在排序数组中出现的次数。

示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: 2
示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: 0

解：找到【最后一个小于target的位置】和【最后一个等于target的位置】 两个位置相减即答案
或者找到【第一个等于target的位置】和【最后一个等于target的位置】 两个位置相减再-1即为答案

class Solution {
    public int search(int[] nums, int target) {
        return helper(nums, target) - helper(nums, target - 1);
    }
    int helper(int[] nums, int tar) {
        int i = 0, j = nums.length - 1;
        while(i <= j) {
            int m = (i + j) / 2;
            if(nums[m] <= tar) i = m + 1;
            else j = m - 1;
        }
        return i;
    }
}

154. 寻找旋转排序数组中的最小值 II

剑指 Offer 11. 旋转数组的最小数字

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,4]
若旋转 7 次，则可以得到 [0,1,4,4,5,6,7]
注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。
给你一个可能存在 重复 元素值的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

示例 1：
输入：nums = [1,3,5]
输出：1
示例 2：
输入：nums = [2,2,2,0,1]
输出：0

解：二分查找


此时right向前移一位 right-- 重新计算mid 再比较 这样做不会对结果造成影响是因为我们要找数组中最小的数 去除掉一个重复的数没有影响啊

代码如下：
JS：

var minArray = function(numbers) {
    if (numbers.length === 1) return numbers[0];
    let begin = 0;
    let end = numbers.length - 1;// [)
    let mid;
    while (begin < end) {
        mid = begin + Math.floor((end - begin) / 2);
        if (numbers[mid] > numbers[end]) {
            begin = mid + 1;
        }else if (numbers[mid] < numbers[end]){
            end = mid;
        }else {
            end--;
        }
    }
    return numbers[begin];
};

378. 有序矩阵中第 K 小的元素

给你一个 n x n 矩阵 matrix ，其中每行和每列元素均按升序排序，找到矩阵中第 k 小的元素。

示例 1：
输入：matrix = [[1,5,9],[10,11,13],[12,13,15]], k = 8
输出：13
解释：矩阵中的元素为 [1,5,9,10,11,12,13,13,15]，第 8 小元素是 13
示例 2：
输入：matrix = [[-5]], k = 1
输出：-5

解：
1.找出二维矩阵中最小的数left，最大的数right，那么第k小的数必定在left ~ right 之间
2.mid=(left+right) / 2；在二维矩阵中寻找小于等于mid的元素个数count
3.若这个count小于k，表明第k小的数在右半部分且不包含mid，即left=mid+1，right=right，又保证了第k小的数在left ~ right之间
4.若这个count大于k，表明第k小的数在左半部分且可能包含mid，即 left=left，right=mid，又保证了第k小的数在 left~right之间
5.因为每次循环中都保证了第k小的数在left ~ right 之间，当 left==right时，第k小的数被找出，等于 right
6.注意：这里的 left mid right 是数值，不是索引位置。
代码如下：
JAVA：

	public int kthSmallest(int[][] matrix, int k) {
        int row = matrix.length;
        int col = matrix[0].length;
        int left = matrix[0][0];
        int right = matrix[row - 1][col - 1];
        while (left < right) {
            // 每次循环都保证第K小的数在start~end之间，当start==end，第k小的数就是start
            int mid = (left + right) / 2;
            // 找二维矩阵中<=mid的元素总个数
            int count = findNotBiggerThanMid(matrix, mid, row, col);
            if (count < k) {
                // 第k小的数在右半部分，且不包含mid
                left = mid + 1;
            } else {
                // 第k小的数在左半部分，可能包含mid
                right = mid;
            }
        }
        return right;
    }

    private int findNotBiggerThanMid(int[][] matrix, int mid, int row, int col) {
        // 以列为单位找，找到每一列最后一个<=mid的数即知道每一列有多少个数<=mid
        int i = row - 1;
        int j = 0;
        int count = 0;
        while (i >= 0 && j < col) {
            if (matrix[i][j] <= mid) {
                // 第j列有i+1个元素<=mid
                count += i + 1;
                j++;
            } else {
                // 第j列目前的数大于mid，需要继续在当前列往上找
                i--;
            }
        }
        return count;
    }

剑指 Offer 04. 二维数组中的查找

在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例:
现有矩阵 matrix 如下：
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。
给定 target = 20，返回 false。

解：思路同上 代码如下：

var findNumberIn2DArray = function(matrix, target) {
    if (!matrix.length) return false;
    let n = matrix.length - 1;
    let m = matrix[0].length - 1;
    if (matrix[0][0] > target || matrix[n][m] < target) return false;
    for (let i = n; i >= 0; i--) {// 行
        for (let j = 0; j <= m; j++) {// 列
            if (matrix[i][j] === target) return true;
            if (matrix[i][j] > target) break;
        }
    }
    return false;
};

二维数组中的查找

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

实例：
[
[1,2,8,9],
[2,4,9,12],
[4,7,10,13],
[6,8,11,15]
]
给定 target = 7，返回 true。
给定 target = 3，返回 false。

解：这道题的思路和上一道一样 代码如下：

function Find(target, array) {
    let n = array.length;
    if (array[0][0] > target || array[n - 1][n - 1] < target) return false;
    for (let i = n - 1; i >= 0; i--) {// 行
        for (let j = 0; j < n; j++) {// 列
            if (array[i][j] === target) return true;
            if (array[i][j] > target) break;
        }
    }
    return false;
}

剑指 Offer 40. 最小的k个数

输入整数数组 arr ，找出其中最小的 k 个数。

示例 1：
输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
示例 2：
输入：arr = [0,1,2,1], k = 1
输出：[0]

解：每次从[start, end]范围内的数组中随机选择一个标杆元素(代码里取得是第一个元素), 然后把数组中所有小于标杆的放在数组左边，所有大于标杆的元素放在数组右边，然后判断标杆元素的位置是否等于目标位置。如果目标位置小于当前位置，则继续在左边查找，如果目标位置大于当前位置，则继续在右边查找。这样每次迭代都会缩小查找的范围。

var getLeastNumbers = function(arr, k) {
    if (k > arr.length) return [];
    if (k === arr.length) return arr;
    let start = 0;
    let end = arr.length - 1;
    function quick (left, right) {
        let num = arr[left];
        // right--;
        while (left < right) {
            while (left < right) {
                if (num < arr[right]) {
                    right--;
                }else {
                    arr[left++] = arr[right];
                    break;
                }
            }

            while (left < right) {
                if (num > arr[left]) {
                    left++;
                }else {
                    arr[right--] = arr[left];
                    break;
                }
            }
        }
        arr[left] = num;
        return left;
    }

    let index = quick(start, end);
    while (index !== k) {
        if (index < k) {
            start = index + 1;
            index = quick(start, end);
        }else {
            end = index - 1;
            index = quick(start, end);
        }
    }
    return arr.slice(0,index);
};

剑指 Offer 53 - II. 0～n-1中缺失的数字

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

例1：输入: [0,1,3] 输出: 2
例2：输入: [0,1,2,3,4,5,6,7,9] 输出: 8

解：依题意 正常情况下 索引应该和值相等 用二分查找 若中间的数不等于索引 说明左边少了一个数 若等于 说明左边没有少数 去右边找缺失的数

var missingNumber = function(nums) {
    let left = 0;
    let right = nums.length - 1;
    let mid;
    while (left < right){
        mid = left + ((right - left) >> 1);
        if (nums[mid] === mid){
            left = mid + 1;
        }else {
            right = mid;
        }
    }
    if (left === nums[left]) return left + 1;
    else return left;
};