題目：

我的解答：

思路很簡單，把所有的資料先讀到ArrayList中然後轉到陣列中，然後排序，然後構建新連結串列

程式碼：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        ArrayList<Integer> arr=new ArrayList<>();
        for(int i=0;i<lists.length;i++) {
        	ListNode list=lists[i];
        	while(list!=null) {
        		int val=list.val;
        		arr.add(val);
        		list=list.next;
        	}
        	
        }
        int size=arr.size();
        int[] data=new int[size];
        for(int i=0;i<size;i++) {
        	data[i]=arr.get(i);
        }
        Arrays.sort(data);
        ListNode list1=new ListNode(0);
        ListNode list2=list1;
        for(int i=0;i<size;i++) {
        	int m=data[i];
        	ListNode k=new ListNode(1);
        	k.val=m;
        	list1.next=k;
        	list1=list1.next;
        }
        return list2.next;
    }
}
 

結果通過；

 第二中方法：

先寫出對兩個連結進行合併的方法，然後採用遞迴+分治的方法合併所有的連結串列

code：

class Solution:
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        
        length =  len(lists)
        if length == 0:
            return lists
        if length == 1:
            return lists[0]
        
        mid = int(length/2)
        left = length%2
        
        l1 = lists[0:mid]
        l2 = lists[mid:2*mid]
        r1 = self.mergeKLists(l1)
        r2 = self.mergeKLists(l2)
        r = self.merge2Lists(r1,r2)   
        if left:
            r = self.merge2Lists(r,lists[-1]) 
        return  r
    
         
            
    def merge2Lists(self,l1,l2):
        head = ListNode(0)
        r = head
        while l1 and l2:
 
            if l1.val < l2.val:
                r.next = l1
                l1 = l1.next
            else:
                r.next = l2
                l2 = l2.next
 
            r = r.next
        if l1:
            r.next = l1
        if l2:
            r.next = l2
        return head.next