LeetCode: Median of Two Sorted Arrays 解題報告

Median of Two Sorted Arrays

There are two sorted arrays A and B of size m and n respectively. Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

SOLTION 1:

1. 我們借用findKthNumber的思想。先實現findKthNumber，如果是偶數個，則把中間2個加起來平均，奇數就用中間的。

2. 為了達到LOG級的復雜度，我們可以這樣：

每次在A，B取前k/2個元素。有以下這些情況：

1).  A的元素個數 < k/2. 則我們可以丟棄B前k/2. 反之亦然

證明：

我們使用反證法。

假設第K大在B的前k/2中，例如位置在索引m(m <= k/2-1)那么A必然擁有前k中的k -(m+1)個元素，而

m <= k/2-1,則 m+1 <= k/2  , k - (m+1) >= k/2與條件：A的元素不夠k/2矛盾，所以假設不成立，得證。

舉個栗子：

A: 6 7 8

B: 1 2 3 4 5

找第8大的數字，

2). A[mid] < B[mid] (mid是k/2 -1索引處的元素）。

這種情況下，我們可以丟棄A前k/2。

證明：

我們使用反證法。

假設第K大在A的前k/2中記為maxK，例如位置在索引m(m <= k/2-1)那么B必然擁有前k中的k -(m+1)個元素，而

m <= k/2-1,則 m+1 <= k/2  , k - (m+1) > k/2

推出B[mid] <= maxK

而A[mid] >= maxK 推出 A[mid]>=B[mid], 與題設矛盾。所以假設不能成立。

舉個栗子：

A: 1 2

B: 4 5 6 7 8

找第四大的數字 我們就可以首先排除1，2.

public double findMedianSortedArrays(int A[], int B[]) {
        if (A == null || B == null) {
            return 0;
        }
        
        int len = A.length + B.length;
        
        double ret = 0;
        // 偶數個元素
        if (len % 2 == 0) {
            ret = (findKth(A, B, 0, 0, len / 2) + findKth(A, B, 0, 0, len / 2 + 1)) / (double)2.0;
        } else {
            // 奇數個元素
            ret = findKth(A, B, 0, 0, len / 2 + 1);            
        }
        
        return ret;
    }
    
    // Find the Kth large number.
    public int findKth(int A[], int B[], int indexA, int indexB, int k) {
        int lenA = A.length;
        int lenB = B.length;
        
        if (indexA >= lenA) {
            return B[indexB + k - 1];
        } else if (indexB >= lenB) {
            return A[indexA + k - 1];
        }
        
        // Base Case, pay attention. 在這里必須要退出。因為k = 1的時候，不可能再分了。
        if (k == 1) {
            return Math.min(A[indexA], B[indexB]);
        }
        
        // -1是因為索引本身是從0開始的。而前k大元素含有k個元素。
        int mid = k / 2 - 1;
        
        // 注意，越界條件是 >= lenA. 怎么老是犯這個錯誤。。
        int keyA = indexA + mid >= lenA ? Integer.MAX_VALUE: A[indexA + mid];
        int keyB = indexB + mid >= lenB ? Integer.MAX_VALUE: B[indexB + mid];
        
        // 因為丟棄了k / 2個元素
        int kNew = k - k / 2;
        
        if (keyA < keyB) {
            return findKth(A, B, indexA + k / 2, indexB, kNew);
        } else {
            return findKth(A, B, indexA, indexB + k / 2, kNew);
        }
    }

 2015.1.25

可以優化一下，在找到kth number時可以及時退出：

public class Solution {
    public double findMedianSortedArrays(int A[], int B[]) {
        //2257
        if (A == null || B == null) {
            return 0;
        }
        
        int len = A.length + B.length;
        if (len % 2 == 0) {
            return (double)(dfs(A, B, 0, 0, len / 2) + dfs(A, B, 0, 0, len / 2 + 1)) / 2.0;
        } else {
            return dfs(A, B, 0, 0, len / 2 + 1);
        }
    }
    
    public double dfs1(int A[], int B[], int aStart, int bStart, int k) {
        if (aStart >= A.length) {
            return B[bStart + k - 1];
        } else if (bStart >= B.length) {
            return A[aStart + k - 1];
        }
        
        if (k == 1) {
            return Math.min(A[aStart], B[bStart]);
        }
        
        // k = 4;
        // mid = 1;
        int mid = k / 2 - 1;
        
        if (aStart + mid >= A.length) {
            // drop the left side of B.
            return dfs(A, B, aStart, bStart + k / 2, k - k / 2);
        } else if (bStart + mid >= B.length) {
            // drop the left side of A.
            return dfs(A, B, aStart + k / 2, bStart, k - k / 2);
        } else if (A[aStart + mid] > B[bStart + mid]) {
            // drop the left side of B.
            return dfs(A, B, aStart, bStart + k / 2, k - k / 2);
        // 當2者相等，有2種情況：
        // 1. 當k為偶數，則kth存在於任何一個結尾處，其實也是可以丟棄一半的。
        // 2. 當k為奇數，則kth不存在於A,B的left side。也是可以丟棄任意一半。
        //} else if (A[aStart + mid] < B[bStart + mid]) {
        } else {
            return dfs(A, B, aStart + k / 2, bStart, k - k / 2);
        }
        
        //return A[aStart + mid];        
    }
    
    public double dfs(int A[], int B[], int aStart, int bStart, int k) {
        if (aStart >= A.length) {
            return B[bStart + k - 1];
        } else if (bStart >= B.length) {
            return A[aStart + k - 1];
        }
        
        if (k == 1) {
            return Math.min(A[aStart], B[bStart]);
        }
        
        // k = 4;
        // mid = 1;
        int mid = k / 2 - 1;
        
        if (aStart + mid >= A.length) {
            // drop the left side of B.
            return dfs(A, B, aStart, bStart + k / 2, k - k / 2);
        } else if (bStart + mid >= B.length) {
            // drop the left side of A.
            return dfs(A, B, aStart + k / 2, bStart, k - k / 2);
        } else if (A[aStart + mid] > B[bStart + mid]) {
            // drop the left side of B.
            return dfs(A, B, aStart, bStart + k / 2, k - k / 2);
        } else if (A[aStart + mid] < B[bStart + mid]) {
            return dfs(A, B, aStart + k / 2, bStart, k - k / 2);
        } else {
            // drop the left side of A.
            //return dfs(A, B, aStart + k / 2, bStart, k - k / 2);
            if (k % 2 == 0){
                return A[aStart + mid];
            }
            
            // can drop both sides.
            return dfs(A, B, aStart + k / 2, bStart + k / 2, 1);
        }
        
        //return A[aStart + mid];        
    }
}

 

GITHUB:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/array/FindMedianSortedArrays.java