LintCode 两个排序数组的中位数

两个排序的数组A和B分别含有m和n个数，找到两个排序数组的中位数，要求时间复杂度应为O(log (m+n))。

样例

给出数组A = [1,2,3,4,5,6] B = [2,3,4,5]，中位数3.5

给出数组A = [1,2,3] B = [4,5]，中位数 3

思路一：

排序数组中中位数是正中间的那个数，若数组长度为偶数则中位数是正中间的两个数的平均数

最简单的方法是先归并两个数组，然后求中位数，但时间复杂度是O(m+n)

double findMedianSortedArrays(vector<int> A, vector<int> B) {
        // write your code here
        vector<int> buf;
        int p1 = 0;
        int p2 = 0;
        while(1) {
            if(p1 < A.size() && p2 < B.size()) {
                if(A[p1] < B[p2]) {
                    buf.push_back(A[p1++]);
                }else {
                    buf.push_back(B[p2++]);
                }
            }else if(p1 < A.size()) {
                buf.push_back(A[p1++]);
            }else if(p2 < B.size()) {
                buf.push_back(B[p2++]);
            }else {
                break;
            }
        }
        int mid = buf.size() / 2;
        if(buf.size() % 2 == 0) {
            return (buf[mid] + buf[mid - 1]) * 0.5;
        }else {
            return buf[mid];
        }
    }

思路二：

不归并，直接用二分法搜索两个数组归并后正中间的一个数或两个数

假设要找的数在A中，则该数在A中的位置加上该数在B中的位置等于中间位置，该数在B中的位置可以通过二分法查到

若在A中没要找到符合要求的数就用同样的方法搜索B中的数

还要注意两个数组中有相同数字情况的处理，我是一趟把相同数字算到左边，一趟把相同数字算到右边

此算法的时间复杂度应该是log(m)*log(n)，要达到O(log (m+n))有待进一步优化

    double findMedianSortedArrays(vector<int> A, vector<int> B) {
        int size = A.size() + B.size();
        int mid = size / 2;
        if(size % 2 == 0) {
            return (findIndex(A, B, mid - 1) + findIndex(A, B, mid)) * 0.5;
        }else {
            return findIndex(A, B, mid);
        }
    }
    
    int findIndex(vector<int>& A, vector<int>& B, int index) {
        int num;
        if(findSub(A, B, index, num, true) == false) {
            findSub(B, A, index, num, false);
        }
        return num;
    }
    
    bool findSub(vector<int>& A, vector<int>& B, int index, int& num, bool low) {
        int begin = 0;
        int end = A.size() - 1;
        while(begin <= end) {
            int mid = (begin + end) / 2;
            int val;
            if(low) {
                val = mid + bfsearchLow(B, A[mid]);
            }else {
                val = mid + bfsearchHigh(B, A[mid]);
            }
            if(val < index) {
                begin = mid + 1;
            }else if(val > index) {
                end = mid - 1;
            }else {
                num = A[mid];
                return true;
            }    
        }
        return false;
    }
    
    int bfsearchLow(vector<int>& arr, int num) {
        int begin = 0;
        int end = arr.size() - 1;
        while(begin <= end) {
            int mid = (begin + end) / 2;
            if(num > arr[mid]) {
                begin = mid + 1;
            }else {
                end = mid - 1;
            }
        }
        return begin;
    }
    
    int bfsearchHigh(vector<int>& arr, int num) {
        int begin = 0;
        int end = arr.size() - 1;
        while(begin <= end) {
            int mid = (begin + end) / 2;
            if(num < arr[mid]) {
                end = mid - 1;
            }else {
                begin = mid + 1;
            }
        }
        return begin;
    }