給你一個連結串列陣列，每個連結串列都已經按升序排列。

請你將所有連結串列合併到一個升序連結串列中，返回合併後的連結串列。

示例 1：

輸入：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

連結：https://leetcode-cn.com/problems/merge-k-sorted-lists
這是目前唯一一題能想到的hard題了，沒有用到什麼特別高深的思想，就是一把梭！！！

自己的思路和程式碼：

1.把所有節點給排序了，然後再重新連起來

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    
 
public ListNode mergeKLists(ListNode[] lists) {
        if(lists==null)
        {
            return null;
        }
        //放到個arraylist裡面 然後就直接排序


        ListNode HeadFake=new ListNode(-9);
        // System.out.println(lists.length);

        // System.out.println(lists[0].val);
        // System.out.println(lists[1].val);
        
 
// System.out.println(lists[2].val);

        List<ListNode> list_new = new ArrayList<ListNode>();
        for(int i=0;i<lists.length;i++)
        {
            while(lists[i]!=null)
            {
                // System.out.println(lists[i].val);
                list_new.add(lists[i]);
                lists[i]=lists[i].next;
            }
        }

        Collections.sort(list_new, new Comparator<ListNode>() {
            public int compare(ListNode a, ListNode b)
            {
                return (a.val-b.val);
            }
        });
        
        ListNode new_head=new ListNode(-1);
        ListNode NewHeadPtr=new_head;
        for (Iterator<ListNode> it = list_new.iterator(); it.hasNext(); ) {
            ListNode s = it.next();
            NewHeadPtr.next=s;
            NewHeadPtr=NewHeadPtr.next;
            // System.out.println(s.val);
        }

        // while(new_head.next!=null)
        // {
        //     // System.out.println(new_head.next.val);
        //     new_head=new_head.next;
        // }

        return new_head.next;



    }
}

Leecode和視訊的題解思想

1.和我的一樣，排序再重連

2.分治合併

class Solution {
public:
    ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, *tail = &head, *aPtr = a, *bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }

    ListNode* merge(vector <ListNode*> &lists, int l, int r) {
        if (l == r) return lists[l];
        if (l > r) return nullptr;
        int mid = (l + r) >> 1;
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return merge(lists, 0, lists.size() - 1);
    }
};

作者：LeetCode-Solution

視訊的思路：

其它：

還有就是發現java不用vector，所以，可以使用List的這個集合，所以有時間要看看java的set了。