LintCode 65: Median of two Sorted Arrays (经典题!!!)

最新推荐文章于 2021-10-21 14:47:55 发布

原创最新推荐文章于 2021-10-21 14:47:55 发布 · 421 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LintCode

algorithm-design 专栏收录该内容

817 篇文章

订阅专栏

本文介绍了一种使用二分查找法寻找两个已排序数组中第K小元素的方法，该方法通过比较两个数组的中间元素来缩小搜索范围，最终找到目标元素，时间复杂度为O(log(m+n))。

这题解法很多。

解法1：二分法。
找两个排序数组中第K小的数。

If startA exceeds A.size(), then the Kth smallest elements should be B[startB + K -1];
If startA exceeds A.size(), then the Kth smallest elements should be B[startB + K -1];
if K == 1, then return the min of A[startA] and B[startB]
if startA + K / 2 is still within arrayA, and
startB + K / 2 is still within arrayB, then compare halfKOfA and halfKOfB:

if halfKOfA > halfKOfB, then the Kth smallest number should be in
A[startA…startA+K/2] and B[startB+K/2…startB+K]

if halfKOfA < halfKOfB, then the Kth smallest number should be in
A[startA+K/2…startA+K] and B[startB…startB+K/2]

Time complexity O(log(m+n)).

class Solution {
public:
    /*
     * @param A: An integer array
     * @param B: An integer array
     * @return: a double whose format is *.5 or *.0
     */
    double findMedianSortedArrays(vector<int> &A, vector<int> &B) {
        int totalLen = A.size() + B.size();
        
        if (totalLen & 0x1) {
            return helper(A, 0, B, 0, totalLen / 2 + 1);
        } else {
            return helper(A, 0, B, 0, totalLen / 2) / 2.0 + helper(A, 0, B, 0, totalLen / 2 + 1) / 2.0;
        }
        
    }
    
private:
    int helper(vector<int> &A, int startA, vector<int> &B, int startB, int K) {
        if (startA >= A.size()) {
            return B[startB + K - 1];
        }
        
        if (startB >= B.size()) {
            return A[startA + K - 1];
        }
        
        if (K == 1) {
            return min(A[startA], B[startB]);
        }
        
        int halfKofA = 0, halfKofB = 0; 
    
        if ((startA + K / 2) > A.size()) {
            halfKofA = INT_MAX;
        } else {
            halfKofA = A[startA + K / 2 - 1];
        }
        
        if ((startB + K / 2) > B.size()) {
            halfKofB = INT_MAX;
        } else {
            halfKofB = B[startB + K / 2 - 1];
        }
        
        if (halfKofA > halfKofB) {
            // should be in the other k/2 of B
            return helper(A, startA, B, startB + K / 2, K - K / 2);
            //return helper(A, startA, B, startB + K / 2, K / 2);
        } else {
            // should be in the other k/2 of a
            return helper(A, startA + K / 2, B, startB, K - K / 2 );
            //return helper(A, startA + K / 2, B, startB, K / 2 );
        }
    }

};