力扣-4-寻找两个正序数组的中位数

1. 题目
   leetcode-4-寻找两个正序数组的中位数
2. 题解
   函数一：合并两个有序且长度相等的数组，取其上中位数。两种情况：

• 数组长度为偶数
  

合并后数组长度为8，上中位数就是第四小的数。
比较两个数组的第二小的数，即B1和B2

• B1 = B2 则第四小的数就是B1或者B2
• B1 > B2 此时B1至少第四小，所以C1、D1不可能；B2至多第三大，所以A2、B2不可能；可能是第四小的数[A1, B1]、[C2, D2]; 将两个数组递归调用，知道两个数组都只剩下一个数，谁小就是上中位数。
• B1 < B2 此时B2至少第四小，所以C2、D2不可能；B1至多第三大，所以A1、B1不可能；可能是第四小的数[C1, D1]、[A2, B2]; 将两个数组递归调用，直到两个数组都只剩下一个数，谁小就是上中位数。

• 数组长度为奇数
  

合并两个数组后长度为10，上中位数就是第五小的数。
比较两个数组第三小的数，即C1和C2

• C1 = C2 则第五小的数为C1或者C2
• C1 > C2 此时C1至少第六小，所以C1、D1、E1不可能；B2至多第四小，所以A2、B2不可能；排除完后剩余两个数组长度不一致，此时比较剩余长数组的最小数和短数组的最大数，如果C2 > B1则C2位第五小，否则排除C2，将两个数组递归调用，直到两个数组都只剩下一个数，谁小就是上中位数。
• C1 < C2 此时C2至少第六小，所以C2、D2、E2不可能；B1至多第四小，所以A1、B1不可能；排除完后剩余两个数组长度不一致，此时比较剩余长数组的最小数和短数组的最大数，如果C1 > B2则C1位第五小，否则排除C1，将两个数组递归调用，直到两个数组都只剩下一个数，谁小就是上中位数。

函数二： 合并两个有序数组但长度可能不一致，求第k小的数，三种情况：
例：短数组长度为3，长数组长度为7

• k <= 短数组长度

k取2，两个数组都取2个数，调用函数一得到的上中位数即第二小的数

• 短数组长度 < k <= 长数组长度

k取5，A2至多为第四小，所以排除A2；F2至少第六小，所以排除F2、G2；
剩下两个数组长度不一致，此时判断B2 > C1 则B2为第五小，否则排除B2两个数组调用函数一得到的上中位数即为第五小。（因为排除A2、B2，再调用函数一得到第三小，即1+1+3=5）

• 长数组长度 < k <= 短数组长度 + 长数组长度

k取8，D2至多第七小，所以排除A2、B2、C2、D2；
因为只排除掉4个数，剩余两个数组长度为3，调用函数一后获取的上中位数为第3小，4 + 4 = 7 小于8，所以两个数组都排除掉一个最小数，此时4 + 2 + 2 = 8；

• A1 >= G2 则A1为第八小的数，否则A1排除
• E2 >= C1 则E2为第八小的数，否则E2排除

3. 代码

public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int len = nums1.length + nums2.length;

        if (len % 2 == 0) {
            int a = findKthUnequalArray(nums1, nums2, len / 2);
            int b = findKthUnequalArray(nums1, nums2, len / 2 + 1);
            return (a + b) * 0.5;
        } else {
            return findKthUnequalArray(nums1, nums2, len / 2 + 1) * 1.0;
        }

    }


    /**
     * 返回两个有序数组排序后的第k小的数
     *
     * @param arr1
     * @param arr2
     * @param k
     * @return
     */
    public int findKthUnequalArray(int[] arr1, int[] arr2, int k) {
        if (arr1.length == 0) {
            return arr2[k - 1];
        } else if (arr2.length == 0) {
            return arr1[k - 1];
        }
        int[] longArr = arr1.length >= arr2.length ? arr1 : arr2;
        int[] shortArr = longArr == arr1 ? arr2 : arr1;
        int m = longArr.length;
        int n = shortArr.length;

        if (k <= n) {
            return upperMedianEqualArray(shortArr, 0, k - 1, longArr, 0, k - 1);
        } else if (k <= m) {
            int s1 = 0;
            int e1 = n - 1;
            int s2 = k - n - 1;
            int e2 = k - 1;
            if (longArr[s2] >= shortArr[e1]) {
                return longArr[s2];
            }
            return upperMedianEqualArray(shortArr, s1, e1, longArr, s2 + 1, e2);
        } else {
            int s1 = k - m - 1;
            int e1 = n - 1;
            int s2 = k - n - 1;
            int e2 = m - 1;
            if (shortArr[s1] >= longArr[e2]) {
                return shortArr[s1];
            } else if (longArr[s2] >= shortArr[e1]) {
                return longArr[s2];
            }
            return upperMedianEqualArray(shortArr, s1 + 1, e1, longArr, s2 + 1, e2);
        }
    }

    /**
     * 两个等长且有序数组返回上中位数
     *
     * @param arr1
     * @param s1
     * @param e1
     * @param arr2
     * @param s2
     * @param e2
     * @return
     */
    public int upperMedianEqualArray(int[] arr1, int s1, int e1, int[] arr2, int s2, int e2) {
        int n = e1 - s1 + 1;
        int index1 = s1 + (e1 - s1) / 2;
        int index2 = s2 + (e2 - s2) / 2;
        if (n == 1) {
            return Math.min(arr1[index1], arr2[index2]);
        }

        if (n % 2 == 0) {
            if (arr1[index1] == arr2[index2]) {
                return arr1[index1];
            } else if (arr1[index1] > arr2[index2]) {
                return upperMedianEqualArray(arr1, s1, index1, arr2, index2 + 1, e2);
            } else {
                return upperMedianEqualArray(arr1, index1 + 1, e1, arr2, s2, index2);
            }
        } else {
            if (arr1[index1] == arr2[index2]) {
                return arr1[index1];
            } else if (arr1[index1] > arr2[index2]) {
                if (arr2[index2] >= arr1[index1 - 1]) {
                    return arr2[index2];
                } else {
                    return upperMedianEqualArray(arr1, s1, index1 - 1, arr2, index2 + 1, e2);
                }
            } else {
                if (arr1[index1] >= arr2[index2 - 1]) {
                    return arr1[index1];
                } else {
                    return upperMedianEqualArray(arr1, index1 + 1, e1, arr2, s2, index2 - 1);
                }
            }
        }
    }