3-5-多数组k大值

题目描述：

　　给定两个有序数组arr1和arr2，在给定一个整数k，返回两个数组的所有数中第K小的数。
　　例如：
　　　　arr1 = {1,2,3,4,5};
　　　　arr2 = {3,4,5};
　　　　K = 1;
　　因为1为所有数中最小的，所以返回1；

　　　　arr1 = {1,2,3};
　　　　arr2 = {3,4,5,6};
　　　　K = 4;
　　因为3为所有数中第4小的数，所以返回3；

要求：如果arr1的长度为N，arr2的长度为M，时间复杂度请达到O(log(min{M,N}))。

/*
    思路：利用上一题NowClass3-4-GetUpMedian的求上中位数的思路进行求解。
        arr1和arr2，其中数组长度分别为：lenS和lenL（lenS<=lenL）
        分情况分析：
            1) kth <= lenS;
                只需求arr1和arr2的前kth个数的上中位数即可。
                即：findProcess(arr1, 0, kth-1, arr2, 0, kth-1).
            2) kth > lenL;
                arr1中前kth-lenL-1个数不可能是第kth个数，
                arr2中前kth-lenS-1个数不可能是第kth个数，
                此时，arr1中剩余(lenS-(kth-lenL-1))=lenS+lenL+1-kth个可能的数，
                arr2中剩余(lenL-(kth-lenS-1))=lenL+lenS+1-kth个可能的数。剩余个数相同。
                然后，先判断arr1中的第kth-lenL-1个数是否大于arr2的最后一个数，
                    如果是则直接返回arr1的第kth-lenL-1个数即可。
                    再判断arr2中的第kth-lenS-1个数是否大于arr1的最后一个数，
                    如果是则直接返回arr2的第kth-lenS-1个数。
                否则求arr1的(kth-lenS,lenS)和arr2的(kth-lenL,lenL)的上中位数。
                即：findProcess(arr1,kth-lenS,lenS,arr2,kth-lenL,lenL).
            3) lenS < kth <= lenL; 
              arr1中lenS个数都有可能，
              arr2中(0, kth-1-lenS-1)和(kth-1,lenL-1)不可能，此时剩余kth-1-(kth-1-lenS-1)=lenS+1个数
                然后，单独对地kth-lenS-1验证，是否大于arr1的最后一个数，如果是则直接返回该数；
                否则，求arr1的(0,lenS-1)和arr2的(kth-lenS,kth-1)个数求上中位数。
                即：findProcess(arr1,0,lenS-1,arr2, kth-lenS, kth-1).
*/

#include <iostream>
#include <vector>
using namespace std;

// 查找两个数组的上中位数。
int findProcess(vector<int> arr1, int l1, int r1, vector<int> arr2, int l2, int r2){
    if (l1 == r1)
        return (arr1[l1] < arr2[l2] ? arr1[l1] : arr2[l2]);
    // 元素个数为奇数，则offset=0；否则offset=1.
    int offset = ((r1-l1+1)&1) ^ 1;
    int mid1 = (l1+r1)/2;
    int mid2 = (l2+r2)/2;
    if (arr1[mid1] > arr2[mid2])
        return findProcess(arr1, l1, mid1, arr2, mid2+offset, r2);
    else if(arr1[mid1] < arr2[mid2])
        return findProcess(arr1, mid1+offset, r1, arr2, l2, mid2);
    else
        return arr1[mid1];
}

int findKthNum(vector<int> arr1, vector<int> arr2, int kth){
    if (kth <= 0 || kth > arr1.size()+arr2.size())
        exit(-1);
    vector<int> arrS = arr1.size() < arr2.size() ? arr1 : arr2;
    vector<int> arrL = arr1.size() < arr2.size() ? arr2 : arr1;
    int lenS = arrS.size();
    int lenL = arrL.size();
    if (kth <= lenS)
        return findProcess(arrS, 0, kth-1, arrL, 0, kth-1);
    else if (kth > lenL){
        if (arrS[kth-lenL-1] >= arrL[lenL-1])
            return arrS[kth-lenL-1];
        else if (arrL[kth-lenS-1] >= arrS[lenS-1])
            return arrL[kth-lenS-1];
        else
            return findProcess(arrS, kth-lenL, lenS-1, arrL, kth-lenS, lenL-1);
    }
    else{
        if (arrL[kth-lenS-1] >= arrS[lenS-1])
            return arrL[kth-lenS-1];
        else
            return findProcess(arrS,0,lenS-1,arrL, kth-lenS, kth-1);
    }
}

int main(){
    vector<int> a1;
    a1.push_back(1);
    a1.push_back(1);
    a1.push_back(1);
    a1.push_back(2);
    a1.push_back(3);
    a1.push_back(4);
    
    a1.push_back(6);
    a1.push_back(6);
    a1.push_back(6);
    
    a1.push_back(8);
    a1.push_back(8);
    a1.push_back(8);
    
    a1.push_back(10);
    a1.push_back(10);
    a1.push_back(10);
    a1.push_back(11);
    a1.push_back(12);
    a1.push_back(18);
    a1.push_back(19);

    vector<int> a2;
    a2.push_back(11);
    a2.push_back(19);
    a2.push_back(21);
    a2.push_back(33);
    a2.push_back(42);
    a2.push_back(50);
    a2.push_back(50);
    cout << findKthNum(a1,a2,19) << endl;
    return 0;
}