leetcode 23合并k个升序链表

/**
 * 给你一个链表数组，每个链表都已经按升序排列。
 *  * 请你将所有链表合并到一个升序链表中，返回合并后的链表。
 * 输入：lists = [[1,4,5],[1,3,4],[2,6]]
 * 输出：[1,1,2,3,4,4,5,6]
 * 解释：链表数组如下：
 * [
 *   1->4->5,
 *   1->3->4,
 *   2->6
 * ]
 * 将它们合并到一个有序链表中得到。
 * 1->1->2->3->4->4->5->6
 *  */
public class L23 {
    public static void main(String[] args) {
        ListNode listNode = new ListNode(1);
        listNode.next = new ListNode(4);
        listNode.next.next = new ListNode(5);

        ListNode listNode1 = new ListNode(1);
        listNode1.next = new ListNode(3);
        listNode1.next.next = new ListNode(4);

        ListNode listNode2 = new ListNode(2);
        listNode2.next = new ListNode(6);

        ListNode[] lists = {listNode, listNode1, listNode2};
        L23 l23 = new L23();
        ListNode listNode3 = l23.mergeKLists(lists);
        while (listNode3 != null) {
            System.out.println(listNode3.val);
            listNode3 = listNode3.next;
        }
    }

    public ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) {
            return null;
        }
        int min = 0;
        int result = Integer.MAX_VALUE;
        for (int i = 0; i < lists.length; i++) {
            if (lists[i] == null) {
                continue;
            }
            int val = lists[i].val;
            if (result > val) {
                result = val;
                min = i;
            }
        }
        for (int i = 0; i < lists.length; i++) {
            if (i == min) {
                continue;
            }
            ListNode list = lists[i];
            addSort(lists[min], list);
        }
        return lists[min];
    }

    private void addSort(ListNode ori, ListNode node) {
        ListNode temp = node;
        ListNode oriTemp = ori;
        ListNode tiee = ori;
        while (temp != null) {
            int val = temp.val;
            int target = oriTemp.val;
            if (target <= val) {
                if (oriTemp.next != null) {
                    tiee = oriTemp;
                    oriTemp = oriTemp.next;
                } else {
                    oriTemp.next = temp;
                    break;
                }
            } else {
                ListNode listNode = new ListNode(val, oriTemp);
                tiee.next = listNode;
                oriTemp = tiee.next;
                temp = temp.next;
            }
        }

    }

    private void deepClone(ListNode tiee, ListNode listNode) {
        tiee.val = listNode.val;
        listNode = listNode.next;
        ListNode temp = tiee;
        while (listNode != null) {
            temp.next = new ListNode(listNode.val);
            listNode = listNode.next;
            temp = temp.next;
        }
    }
}

总结

总高用时2.5h，时间长

• 没有考虑用中间变量作为答案，再找那个链表作为答案时浪费了时间，而且还遇到了深度拷贝问题，没有处理好
• 刚开始用两个方法互相递归时报堆栈溢出异常，要善用循环
• 题解中优先队列思路要作为参考