二分法(更新至7.21)

写在前面——

排序数组中找数字：二分法常用的技巧

简单但经典。

统计一个数字在排序数组中出现的次数。
如:
输入: nums = [5,7,7,8,8,10], target = 8
输出: 2

其实思路很简单也很经典，二分法两次分别寻找左右边界

左边界寻找：
① middle > target：右边界 - 1 ② middle < target：左边界 + 1 ③ middle = target：右边界 - 1
返回right：停留在第一个小于target的元素上
右边界寻找：
① middle > target：右边界 - 1 ② middle < target：左边界 + 1 ③ middle = target：左边界 + 1
返回left：停留在第一个大于target的元素上
return 右边界 - 左边界 - 1
注意一个特殊情况：找到左边界之后如果值不等于target，直接返回0，因为这个数压根没出现过。停在哪非常关键，一定要脑补！

优化情况，也是很多二分法会用到的，我们只找两次右边界！分别找target - 1和target的右边界。
右边界寻找：
① middle > target 右边界 - 1 ② middle < target 左边界 + 1 ③ middle = target 左边界 + 1
返回left
最终返回left1 - left2

不管存不存在target该元素，会停留在第一个大于target的数上！所以直接相减。

第k小/大

其实这道题在牛客出现过，思路是用快排，但我现在也忘了- -
二分法 + 快排的思路是：
设数组元素个数为n，每次利用快排对当前的第一个数进行索引确定。
①：如果索引 = k - 1，皆大欢喜，返回；
②：如果索引 < k - 1，往右边找；
③：如果索引 > k - 1，往左边找。
附上代码：

import java.util.*;

public class Solution {
    public int findKth(int[] a, int n, int K) {
        sort(a,0,n-1,K) ;
        return a[K-1]; 
    }
    public void sort(int[] a,int left,int right, int k){
        if(right>left){
            int index = partition(a, left, right);
            if (index == k-1) 
                 return;
            else if(index > k-1)
                 sort(a, left, index - 1,k);
            else
                 sort(a, index + 1, right,k);
            }

    }
    public int partition(int[] a, int left, int right) {
        int pivot = left;
        int index = pivot + 1;
        for (int i = index; i <= right; i++) {
            if (a[i] > a[pivot]) {
                swap(a, i, index);
                index++;
            }
        }
        swap(a, pivot, index - 1);
        return index - 1;
    }
    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

对于索引位置的确定，可以参考我画的示意图：

两个有序数组找第k小

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

设总数组长度m + n，找中位数，即找第 (m + n) / 2 + 1个数（奇），或者第 (m + n) / 2和第(m + n) / 2 + 1的平均值（偶）。
这题的思路，还是在二分法二分什么。并不是二分数组总长度，而是二分第k个数！

假设找第k个数，在两个数组中比较A[k / 2 - 1]和B[k / 2 - 1]，每次比较都会排除某一个数组的 0 … k / 2 - 1共 k / 2个数。排除完之后从寻找第 k 个数变为寻找 第 k - 排除个数 个数，下面列举一些重点：
① 如果迭代至寻找第1个数（k = 1），到达了终止条件，则返回两个数组的起始最小值。
② 如果一个数组为空，到达了终止条件，则返回另一个数组第k个值。
③ 如果数组[k / 2 - 1]越界，则改为取数组最后一个元素，这种情况排除个数不是k / 2了，要重新计算。

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        def getKthElement(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 的值，减去删除的数的个数
            """
            
            index1, index2 = 0, 0
            while True:
                # 特殊情况
                if index1 == m:
                    return nums2[index2 + k - 1]
                if index2 == n:
                    return nums1[index1 + k - 1]
                if k == 1:
                    return min(nums1[index1], nums2[index2])

                # 正常情况
                newIndex1 = min(index1 + k // 2 - 1, m - 1)
                newIndex2 = min(index2 + k // 2 - 1, n - 1)
                pivot1, pivot2 = nums1[newIndex1], nums2[newIndex2]
                if pivot1 <= pivot2:
                    k -= newIndex1 - index1 + 1
                    index1 = newIndex1 + 1
                else:
                    k -= newIndex2 - index2 + 1
                    index2 = newIndex2 + 1
        
        m, n = len(nums1), len(nums2)
        totalLength = m + n
        if totalLength % 2 == 1:
            return getKthElement((totalLength + 1) // 2)
        else:
            return (getKthElement(totalLength // 2) + getKthElement(totalLength // 2 + 1)) / 2