合并N个长度为L的有序数组为一个有序数组

https://www.cnblogs.com/guoyaohua/p/8618977.html
方案一：

新建一个N*L的数组，将原始数组拼接存放在这个大数组中，再调用Arrays.sort()进行排序，或者使用其它排序方法即可。

其实这个题与合并链表很像，但是如果没有指定每个数组的长度，做起来就不太方便，所以一般的前提就是数组长度是一致的

class Solution {
    public int[] merge(int[][] array) {
        int len = array.length;
        if(len == 0) return new int[]{};
        
        int col = array[0].length;
        int[] result = new int[len * col];
        for(int i = 0; i < len; i++){
            for(int j = 0; j < col; j++){
                result[i * len + j] = array[i][j];
            }
        }
        Arrays.sort(result);
        return result;
    }
}

2.相同的方法，利用最小堆来做，但是需要重新定义节点，不然不方便取下一个点

class Node{
    int val;
    int id;//记录所属的维数
    public Node(int val, int id){
        this.val = val;
        this.id = id;
    }
}
class Solution {
    public int[] merge(int[][] array) {
        int row = array.length;
        if(row == 0) return new int[]{};

        int col = array[0].length;
        int[] result = new int[row * col];
        PriorityQueue<Node> pq = new PriorityQueue<>(row, new Comparator<Node>() {
            @Override
            public int compare(Node o1, Node o2) {
                return o1.val - o2.val;//虽然默认就是小顶堆，但是由于是node关系
            }
        });
        //需要再建立一个数组用来记录每个数组当前的进度index
        int[] index = new int[col];
        for(int i = 0; i < row; i++){
            Node node = new Node(array[i][index[i]++], i);//每一行的每个元素加入
            pq.add(node);
        }
        int now = 0;
        while(now < row * col){
            Node node = pq.poll();
            result[now++] = node.val;
            if(index[node.id] < col){
                pq.add(new Node(array[node.id][index[node.id]++], node.id));
            }
        }
        
        return result;
    }
}