Algorithm 如何找到m个排序数组的中值？

如何找到M个排序整数数组的中值？其中，每个数组的大小以N为界。假设每个数组包含已排序的整数元素

这个问题有两种变体

每个数组具有相同的大小

每个数组有不同的大小

---

既然你没有提到你试过什么，我就给你一个提示：

1. Create a min heap (MIN-HEAPIFY) using all the 0-th element of the m arrays
2. Extract min and add an element into the heap from the array from which the min was extracted
3. Assuming all m arrays are of n length EXTRACT-MIN from heap till you get m*n/2 elements.

尝试证明这个解决方案是如何工作的，并提出一个代码。

java版本

public class Solution {
    /**
     * @param nums: the given k sorted arrays
     * @return: the median of the given k sorted arrays
     */
    public double findMedian(int[][] nums) {
        int n = getTotal(nums);
        if (n == 0) {
            return 0;
        }

        if (n % 2 != 0) {
            return findKth(nums, n / 2 + 1);
        }

        return (findKth(nums, n / 2) + findKth(nums, n / 2 + 1)) / 2.0;
    }

    private int getTotal(int[][] nums) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i].length;
        }
        return sum;
    }

    // k is not zero-based, it starts from 1.
    private int findKth(int[][] nums, int k) {
        int start = 0, end = Integer.MAX_VALUE;

        // find the last number x that >= k numbers are >= x. 
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (getGTE(nums, mid) >= k) {
                start = mid;
            } else {
                end = mid;
            }
        }

        if (getGTE(nums, start) >= k) {
            return start;
        }

        return end;
    }

    // get how many numbers greater than or equal to val in 2d array
    private int getGTE(int[][] nums, int val) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += getGTE(nums[i], val);
        }
        return sum;
    }

    // get how many numbers greater than or equal to val in an array
    private int getGTE(int[] nums, int val) {
        if (nums == null || nums.length == 0) {
            return 0;
        }

        int start = 0, end = nums.length - 1;

        // find first element >= val 
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (nums[mid] >= val) {
                end = mid;
            } else {
                start = mid;
            }
        }

        if (nums[start] >= val) {
            return nums.length - start;
        }

        if (nums[end] >= val) {
            return nums.length - end;
        }

        return 0;
    }
    }

公共类解决方案{
/**
*@param nums：给定的k个排序数组
*@return：给定k个排序数组的中位数
*/
公共双findMedian（int[][]nums）{
int n=getTotal（nums）；
如果（n==0）{
返回0；
}
如果（n%2！=0）{
返回findKth（nums，n/2+1）；
}
返回（findKth（nums，n/2）+findKth（nums，n/2+1））/2.0；
}
私有int getTotal（int[][]nums）{
整数和=0；
对于（int i=0；i=k个数>=x的最后一个数x。
while（开始+1<结束）{
int mid=start+（end-start）/2；
if（getGTE（nums，mid）>=k）{
开始=中间；
}否则{
结束=中间；
}
}
if（getGTE（nums，start）>=k）{
返回启动；
}
返回端；
}
//获取2d数组中大于或等于val的数字数
私有int getGTE（int[][]nums，int val）{
整数和=0；
对于（int i=0；i=val
while（开始+1<结束）{
int mid=start+（end-start）/2；
如果（nums[mid]>=val）{
结束=中间；
}否则{
开始=中间；
}
}
如果（nums[start]>=val）{
返回nums.length-开始；
}
如果（nums[end]>=val）{
返回nums.length-结束；
}
返回0；
}
}

那么您是在寻找

m

排序数组串联的单个中位数？到目前为止你试过什么？什么是排序数组？@teepeemm我很抱歉措辞不好。我已经更新了问题。我尝试扩展两个不同大小的排序数组的中值算法。但无法达到特定的复杂性。@如果有M个排序数组，则每个数组包含整数元素。希望这一点现在清楚了。这仍然不能告诉我们到目前为止您尝试了什么。我认为答案是相同的，但这种情况下的复杂性是创建堆O（M）+从堆中提取MN/2个元素将导致MNlogM复杂性，因此总体复杂性将是O（MNlogM），我正在寻找更好的方法。从堆中提取一个min元素将是O（lgM）因此，提取n/2元素将是O（NlgM）。参考：Cormen等人的算法简介。Heapsort章节，HEAP-EXTRACT-MAX algorithmm您从HEAP中提取了多少元素？？？MN/2对吗？您需要调用extract MIN MN次，每次调用将花费logM，因此总计为MNlogM。是的，您是正确的，我将N误认为是整个输入大小，而N实际上是一个数组的大小。如果你想要一个比这更好的算法，那么你必须进行二进制搜索。今晚晚些时候我会用代码和方法更新帖子。@ShankhoneerChakrovarty你的答案在哪里？