两个数组中，找出最大的k个数字。

问题描述：

问题一：给定两个整数数组A和B。A和B的长度均为n、元素从小到大排好序了。希望从A和B两个数组中的上中位数。

问题二：给定两个整数数组A和B。A是长度为m、元素从小到大排好序了，B是长度为n、元素从小到大排好序了。希望从A和B数组中，找出最大的k个数字。

思路：

问题一思路：

        当A和B数组的两个上中位数相同时，直接返回答案。

A和B的长度n可以分为奇数和偶数两种情况。

当n为偶数时：

 eg：arr1 = {a,b,c,d};   arr2 = {e,f,g,h}，求第4大的数

1. 当 b==f 时，有 b，f均为上中位数      
2. 当 b < f 时， abe 均小于 f，所以前三个最小的数中包含 ab；而 gh 大于 f，即 gh 大于abef，所以 gh 肯定不为第四大的数，所以第四大的数只能在 cd 和 ef 中产生，所以递归查找 cdef 中上中位数。
3. 当 b > f 时， 同理可得第四大的数只能在 ab 和 gh 中产生，所以递归查找 abgh 上中位数。

当n为奇数时：

   eg：arr1 = {a,b,c,d,e};   arr2 = {f,g,h,i,j}，求第5大的数

1. 当 c==h 时，有c，h均为上中位数
2. 当 c < h 时，abc均小于h，fg 小于 h，所以 hij 肯定为第五位之后的数，那么只需考虑 abc 和 fg 是否符合要求。但是此时无法进行递归求解，因为两个数组长度不相等，所以要手动判断 c和g 的关系
3. c==g：c，g均为上中位数
4. c < g：abc 为前四小的其中三个数，所以第五大的数只能在 de 和 fg 中产生，所以递归查找 defg 中上中位数。
5. c > g：abfg 均小于 c，c为上中位数
6. 当 c > h 时：解法同2

问题二思路：

        该题对于求解的第 k 大的数中的 k 参数有不同的求解方式，假设数组A长度为10，数组B长度为15。

eg：注意：数组中的数字只代表位置，不表示值

        arr1 = {1,2,3,4,5,6,7,8,9,10}     arr1.length = len1

        arr2 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}     arr2.length = len2

1。 当1<=k<=10时（1<=k<=len1），假设k=6
        因为 k=6 ，<len1 && <len2，所以第六小的数只可能出现在两个数组的前六个数中。

        所以我们只需调用求上中位数的函数，传入两个数组的前六位数即可

2。 当10<k<15时（len1<k<len2），假设k=12
        因为 k=12，所以 arr1 中全部数都有可能，数组 arr2 中，1（最大为第11个数），13-15（最小为13-15个数）不可能，所以满足条件的为 2-12 共11个数，而第一个数组为10个数，两个数组长度不同，不能调用函数，所以需要手动判断一个数，即 arr2 中的 2 

        arr2[2] >=arr1[10]：arr[2]为第12个数
        arr2[2] < arr1[10]：arr[2]最大为第11个数，不满足要求，淘汰，求解arr1[1-10],arr2[3-12]
        求解出上中位数后（第十个）加上淘汰的两个，正好为第十二个数

3。 当 15<=k<=25时（len2<=k），假设k=20
        因为 k=20，所以arr2[10]之前的数都不满足要求（当arr1中全部元素全部压在arr2[10]之前，则arr2[10]能达到第20个数，之前的不满足要求），同理求出 arr1 中满足条件的，即

        arr1[5]-arr1[10],arr2[10]-arr2[15]，但只求出这两个数组的上中位数时会发现，之前淘汰掉了4+9=13个数，加上上中位数 6 =19，不是20，所以在求上中位数之前要先判断两个数组最左元素是否满足要求

        arr1[5] >arr2[15]：返回arr1[5]
        arr2[10]>arr1[10]：返回arr2[10]
        如果都不满足，则求解arr1[6]-arr1[10],arr2[11]-arr2[15]
        这时，arr1 淘汰了5个数，arr2 淘汰了10个数，加上上中位数 5 正好为第20个数

代码

问题一代码：

    public static int getUpMedian(int[] A, int s1, int e1, int[] B, int s2, int e2) {
        int mid1 = 0;
        int mid2 = 0;
        while (s1 < e1) {
            mid1 = (s1 + e1) / 2;
            mid2 = (s2 + e2) / 2;
            if (A[mid1] == B[mid2]) {//中位数两个数相同直接输出答案
                return A[mid1];
            }
            if (((e1 - s1 + 1) & 1) == 1) {//奇数长度
                if (A[mid1] > B[mid2]) {
                    //为保证接下来的两个数组长度相同，提前判断B[mid2]>=A[mid1-1]，如符合直接可以输出答案
                    if (B[mid2] >= A[mid1 - 1]) {
                        return B[mid2];
                    }
                    //A数组中s1~mid-1进入下次循环
                    e1 = mid1 - 1;
                    //B数组中mid2+1~e2进入下次循环
                    s2 = mid2 + 1;
                } else {//A[mid1]<B[mid2]
                    //为保证接下来的两个数组长度相同，提前判断A[mid1]>=B[mid2-1]，如符合直接可以输出答案
                    if (A[mid1] >= B[mid2 - 1]) {
                        return A[mid1];
                    }
                    //B数组中时s2~mid2-1进入下次循环
                    e2 = mid2 - 1;
                    //A数组中mid1+1~e1进入下次循环
                    s1 = mid1 + 1;
                }
            } else {//偶数长度
                if (A[mid1] > B[mid2]) {
                    //A数组中s1~mid1进入下次循环
                    e1 = mid1;
                    //B数组中时mid2+1~e2进入下次循环
                    s2 = mid2 + 1;
                } else {
                    //B数组中时s2~mid2进入下次循环
                    e2 = mid2;
                    //A数组中mid1+1~e1进入下次循环
                    s1 = mid1 + 1;
                }
            }
        }
        return Math.min(A[s1], B[s2]);
    }

问题二代码：

    public static int findKthNum(int[] arr1, int[] arr2, int kth) {
        if (arr1 == null || arr2 == null) {
            return -1;
        }
        if (kth < 1 || kth > arr1.length + arr2.length) {
            return -1;
        }
        int[] longs = arr1.length >= arr2.length ? arr1 : arr2;
        int[] shorts = arr1.length < arr2.length ? arr1 : arr2;
        int l = longs.length;
        int s = shorts.length;
        // 1 <= kth <= 短数组的长度
        if (kth <= s) {
            return getUpMedian(shorts, 0, kth - 1, longs, 0, kth - 1);
        }
        // 长数组的长度 <= kth <= 短数组和长数组的长度和
        if (kth > l) {
            if (shorts[kth - l - 1] >= longs[l - 1]) {
                return shorts[kth - l - 1];
            }
            if (longs[kth - s - 1] >= shorts[s - 1]) {
                return longs[kth - s - 1];
            }
            return getUpMedian(shorts, kth - l, s - 1, longs, kth - s, l - 1);
        }
        // 短数组的长度 <= kth <= 长数组的长度
        if (longs[kth - s - 1] >= shorts[s - 1]) {
            return longs[kth - s - 1];
        }
        return getUpMedian(shorts, 0, s - 1, longs, kth - s, kth - 1);
    }

测试代码：

    public static int[] getSortedAllArray(int[] arr1, int[] arr2) {
        if (arr1 == null || arr2 == null) {
            throw new RuntimeException("You arr is invalid!");
        }
        int[] arrAll = new int[arr1.length + arr2.length];
        int index = 0;
        for (int i = 0; i != arr1.length; i++) {
            arrAll[index++] = arr1[i];
        }
        for (int i = 0; i != arr2.length; i++) {
            arrAll[index++] = arr2[i];
        }
        Arrays.sort(arrAll);
        return arrAll;
    }

    public static int[] generateSortedArray(int len, int maxValue) {
        int[] res = new int[len];
        for (int i = 0; i != len; i++) {
            res[i] = (int) (Math.random() * (maxValue + 1));
        }
        Arrays.sort(res);
        return res;
    }

    public static void printArray(int[] arr) {
        for (int i = 0; i != arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int len1 = 10;
        int len2 = 23;
        int maxValue1 = 20;
        int maxValue2 = 100;
        int[] arr1 = generateSortedArray(len1, maxValue1);
        int[] arr2 = generateSortedArray(len2, maxValue2);
        printArray(arr1);
        printArray(arr2);
        int[] sortedAll = getSortedAllArray(arr1, arr2);
        printArray(sortedAll);
        int kth = 17;
        System.out.println(findKthNum(arr1, arr2, kth));
        System.out.println(sortedAll[kth - 1]);

    }