Median of Two Sorted Arrays(尋找兩個有序數組的中位數)

題目

There are two sorted arrays nums1 and nums2 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)).

You may assume nums1 and nums2 cannot be both empty.

Example 1:

nums1 = [1, 3]
nums2 = [2]

The median is 2.0

Example 2:

nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

題意

給定兩個有序數組，且並不都爲空，找出兩個有序數組的中位數，要求時間複雜度是O(log(m+n))。

分析

【方法1】最暴力的解法是將兩個數組合併爲一個，然後找中位數，該方法的時間複雜度是O(m+n)，不符合題意，遂棄之。

【方法2】看到時間複雜度要求，可以想到使用二分查找法。於是就有了如下的解決思路：

假設兩個數組分別爲A和B，A數組的元素個數爲m，B數組的元素個數爲n。

在A數組的隨機位置將數組A分成兩部分，即left_A | right_A，A數組即: A[0], A[1], ...，A[i-1], A[i], A[i+1]，...,  A[m-1]。因爲A有m個元素，所以共有m+1種切割方法(i = 0 ~ m)，其中：left_A.size() = i，right_A.size() = m-i。i = 0 時，left_A.size() = 0； i = m時，right_A.size() = m。

在B數組也做類似的操作：left_B | right_B，B數組：B[0], B[1], ..., B[j-1], B[j], B[j+1],  ..., B[n-1]。

將left_A和left_B放入一個集合，right_A和right_B放入另一個集合。分別命名爲left_part和right_part：left_part | right_part。

A[0], A[1], ...，A[i-1], A[i], A[i+1]，...， A[m-1]

B[0], B[1], ...,  B[j-1], B[j], B[j+1],   ...,   B[n-1]

如果可以保證：

(1) left_part.size() == right_part.size()

(2) max(left_part) <= min(right_part)

那麼將{A，B}中的所有元素劃分爲兩個長度相等的部分，一個部分總是大於另一個部分。然後中值 = (max(left_part) + min(right_part))/2。

爲了確保這個條件，只需要確保兩個條件：

(1）i + j = m-i + n - j（或：m-i + n- j + 1）

如果n>=m,則i = 0 ~m，j = (m+n+1)/2 - i

[tips]爲什麼要確保n>=m，因爲必須確保 j 是合法索引，因爲 0<=i<=m 和 j = (m+n+1)/2 - i，如果n<m，則 j 可以是負數，這將導致錯誤的結果。

(2) B[j-1] <= A[i] 並且A[i-1] <= B[j]

 

在[0,m]中搜索i，找到一個切分點i (j = (m + n + 1)/2 - i)：使得B[j-1] <= A[i]和A[i-1] <= B[j]。可以按照以下步驟進行搜索：

① 設置imin = 0，imax = m，然後開始搜索[imin, imax]；

②設置i = (imin + imax)/2， j = （m+n+1)/2- i；

③現在left_part.size() = right_part.size()，而且只有三種情況：

(1) B[j-1] <= A[i] 和 A[i-1] <= B[j]，意味着找到了切分點i，停止搜索。

(2) B[j-1] > A[i]，意味着A[i]太小，必須調整i 得到B[j-1] <= A[i]。只能增加i，因爲當i減小時j將增加，因此B[j-1]增加並且A[i]減小，永遠不會滿足。所以調整搜索範圍爲[i+1，imax]，即imin = i+1,然後回到第②步。

(3)A[i-1] > B[j]，意味着A[i-1]太大，必須減小 i 得到A[i-1] <= B[j]。因此設置imax = i -1，然後回到第②步。

當找到切分點i時，中值爲：

• 當m+n爲奇數時，中值爲max(A[i-1], B[j-1])
• 當m+n爲偶數時，中值爲((max(A[i-1], B[j-1]) + min(A[i], B[i]))/2

C++代碼實現：

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int len1 = nums1.size();
        int len2 = nums2.size();
        //printf("len1 = %d, len2 = %d\n", len1, len2);
        if(len1 == 0 && len2 > 0) {
            if(len2 % 2 == 0)
                return (nums2[len2/2] + nums2[len2/2 - 1])/2.0;
            else
                return nums2[len2/2];
        } else if (len2 == 0 && len1 > 0) {
            if(len1 % 2 == 0)
                return (nums1[len1/2] + nums1[len1/2 - 1])/2.0;
            else
                return nums1[len1/2];
        }

        if(len1 > len2) {
            return findMedianSortedArrays(nums2, nums1);
        }

        int imin = 0, imax = len1;
        int i,j;
       // printf("imax = %d\n", imax);
        int left_part_max;
        int right_part_min;
        while(imin <= imax) {
            i = imin + (imax - imin)/2;
            j = (len1 + len2 + 1)/2 - i;
           // printf("i = %d, j = %d\n", i, j);
           // printf("nums1[i-1]=%d,nums2[j]=%d,nums2[j-1]=%d,nums1[i]=%d\n");
            if (i < len1 && j > 0 && nums2[j-1] > nums1[i]) {
           //     printf("Adjust imin!\n");
                imin = i + 1;

            } else if (i > 0 && j < len2 && nums1[i-1] > nums2[j]) {
           //     printf("Adjust imax!\n");
                imax = i - 1;
            } else {
                if(i == 0)
                    left_part_max = nums2[j-1];
                else if(j == 0)
                    left_part_max = nums1[i-1];
                else
                    left_part_max = nums1[i-1] > nums2[j-1]? nums1[i-1]:nums2[j-1];
                break;
            }
        }

        if((len1 + len2) % 2 != 0) {
            return left_part_max;
        }
        if(i == len1) {
            right_part_min = nums2[j];
        } else if(j == len2) {
            right_part_min = nums1[i];
        } else {
            right_part_min = nums1[i] < nums2[j]? nums1[i]:nums2[j];
        }
        return (left_part_max + right_part_min)/2.0;
    }
};

【方法3】算法半島主頁
從題目可以知道，需要讓我們在兩個有序數組中找中位數。我們先分析一個有序數組的中位數，當有序數組的個數爲奇數時，如nums=[1, 2, 3, 4, 5]，該數組的中位數爲nums[2]=3；當有序數組的個數爲偶數時，如nums=[1, 2, 3, 4, 5, 6]，該數組的中位數爲(nums[2]+nums[3])/2=3.5。如圖1所示，我們用同一公式可求出任意個數有序數組的中位數。

理解一個有序數組中位數求解過程後，對於兩個有序數組來說，我們只要找出第(m+n+1)/2大的數和第(m+n+2)/2大的數，然後求平均數即可。注意這裏的第(m+n+1)/2大的數中m和n分別指兩個數組的大小，m+n如圖1中的nums.length，第(m+n+1)/2大的數是指我們假設這兩個數組組合成一個有序數組後找出第(m+n+1)/2大的數（這裏爲什麼沒有像圖1中進行減1？因爲我們這裏說的第幾大的數下標是從1開始的；而圖1中需要減1是因爲使用的數組，下標是從0開始的）。

接下來我們在這兩個有序數組中找到第(m+n+1)/2大的數和第(m+n+2)/2大的數，抽象後可表述爲在兩個有序數組中找第k大的數。由於題目要求我們的時間複雜度爲O(log(m+n))，我們很容易聯想到二分查找。當查找時，我們還需要考慮一些特殊情況：(1) 當某個數組查找的起始位置大於等於該數組長度時，說明這個數組中的所有數已經被淘汰，則只需要在另一個數組找查找即可。(2)如果k=1時，即需要查找第一個數，則找到兩個數組起始位置中最小的那個即可。處理完特殊情況後，我們來分析一般情況。這裏所說的二分是指對數組的大小進行二分還是指對k進行二分。以前我們對一維數組進行二分查找時，一般都是對數組大小進行二分，而這裏需要對k進行二分。意思是，我們需要在兩個數組查找第k/2大的數，由於這兩個數組的長度不定，有可能存在有一個數組中沒有第k/2大的數，如果沒有則賦值爲整型最大值。

•  Java代碼 -- 遞歸

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length, n = nums2.length;
        int l = (m + n + 1) / 2;
        int r = (m + n + 2) / 2;
        return (getKth(nums1, 0, nums2, 0, l) + getKth(nums1, 0, nums2, 0, r)) / 2.0;
    }

    // 在兩個有序數組中二分查找第k大元素
    private int getKth(int[] nums1, int start1, int[] nums2, int start2, int k){
        // 特殊情況(1):當某個數組查找的起始位置大於等於該數組長度時，說明這個數組中的所有數已經被淘汰，則只需要在另一個數組找查找即可
        if(start1 > nums1.length-1) return nums2[start2 + k - 1];
        if(start2 > nums2.length-1) return nums1[start1 + k - 1];
        // 特殊情況(2):如果k=1時，即需要查找第一個數，則找到兩個數組起始位置中最小的那個即可
        if(k == 1) return Math.min(nums1[start1], nums2[start2]);
 
        // 分別在兩個數組中查找第k/2個元素，若存在（即數組沒有越界），標記爲找到的值；若不存在，標記爲整數最大值
        int nums1Mid = start1 + k/2 - 1 < nums1.length ? nums1[start1 + k/2 - 1] : Integer.MAX_VALUE;
        int nums2Mid = start2 + k/2 - 1 < nums2.length ? nums2[start2 + k/2 - 1] : Integer.MAX_VALUE;
 
        // 確定最終的第k/2個元素，然後遞歸查找
        if(nums1Mid < nums2Mid)
            return getKth(nums1, start1 + k/2, nums2, start2, k-k/2);
        else
            return getKth(nums1, start1, nums2, start2 + k/2, k-k/2);
    }
}

遞歸的層次比較深，如果數據足夠大，用C++語言實現，可能會出現棧溢出，所以下面用了循環實現。

• C++代碼實現 -- 循環

class Solution {
public:
    int findkth1 (vector<int>& nums1, int start1, vector<int>& nums2, int start2, int k) {
        while(k>1){
            if(start1 >(int)(nums1.size()-1)) return nums2[start2 + k -1];
            if(start2 >(int)(nums2.size()-1)) return nums1[start1 + k -1];
            int nums1mid = start1 + k/2 -1 < nums1.size() ? nums1[start1 + k/2 -1] : INT_MAX;
            int nums2mid = start2 + k/2 -1 < nums2.size() ? nums2[start2 + k/2 -1] : INT_MAX;

            if(nums1mid > nums2mid) start2 += k/2;
            else start1 += k/2;
            k -= k/2; //比較之後，砍去了k/2個數，原先要找第k大，所以現在就要找第k - k/2大
        }   
        if(start1 >(int)(nums1.size()-1)) return nums2[start2 + k -1];
        if(start2 > (int)(nums2.size()-1)) return nums1[start1 + k -1]; 
        if(1==k) return min(nums1[start1], nums2[start2]);
        return 0.0;
    }   
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size();
        int n = nums2.size();
        // add l and r to choose thr lst and rst large data(not the subscript)
        int l = (m+n+1)/2;
        int r = (m+n+2)/2;
        return ((double)findkth1(nums1, 0, nums2, 0, l) + (double)findkth1(nums1, 0, nums2, 0, r))/2;
    }   
};