合并 k 個排序鏈表，返回合并后的排序鏈表。請分析和描述算法的復雜度。

示例:

輸入:
[
1->4->5,
1->3->4,
2->6
]
輸出: 1->1->2->3->4->4->5->6

方法一：
使用vector數組存多個鏈表的所有節點，進行從小到大的排序，完成后再進行元素的指向，從第一個元素指向最后一個元素

bool cmp(ListNode *l1, ListNode *l2) {return l1 -> val < l2 -> val;
}ListNode* mergeKLists(vector<ListNode*>& lists) {vector<ListNode *> node_vec;for (int i = 0;i < lists.size();   i) {while(lists[i]){node_vec.push_back(lists[i]);lists[i] = lists[i] -> next;}}if (node_vec.size() == 0) {return NULL;}//從小到大排序std::sort(node_vec.begin(), node_vec.end(), cmp);for(int i = 1;i < node_vec.size();   i) {node_vec[i-1] -> next = node_vec[i];}//將最后一個元素的next指針指向空node_vec[node_vec.size() - 1] -> next = NULL;return node_vec[0];
}

時間復雜度：
設有k個鏈表，平均每個鏈表有n個節點
kNlogkN kN = O(kNlogkN)

方法二：
分治法，即將所有鏈表分治合并為兩個鏈表，再將兩個鏈表合并為一個有序鏈表
實現如下:

//合并兩個鏈表
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {ListNode new_head(0);ListNode *pre_new = &new_head;while(l1 && l2) {if (l1 -> val < l2 -> val) {pre_new -> next = l1;l1 = l1 -> next;} else {pre_new -> next = l2;l2 = l2 -> next;}pre_new = pre_new -> next;}if (l1) {pre_new -> next = l1;} if (l2) {pre_new -> next = l2;}return new_head.next;
}ListNode* mergeKLists(vector<ListNode*>& lists) {if (lists.size() == 0) return NULL;if (lists.size() == 1) return lists[0];if (lists.size() == 2) {return mergeTwoLists(lists[0],lists[1]);}int mid = lists.size() / 2;vector<ListNode *> sub_list1;vector<ListNode *> sub_list2;for (int i = 0;i < mid; i  ) {sub_list1.push_back(lists[i]);}for (int i = mid;i < lists.size();   i) {sub_list2.push_back(lists[i]);}/*分治鏈表節點，兩兩合并*/ListNode *l1 = mergeKLists(sub_list1);ListNode *l2 = mergeKLists(sub_list2);return mergeTwoLists(l1,l2);
}

時間復雜度：
設有k個鏈表，平均每個鏈表有n個節點
第1輪，進行k/2次，每次處理2n個數字;
第2輪，進行k/4次，每次處 理4n個數字;…;
最后一次，進行k/(2^{logk)次，每次處理2}logk*N個值。

2N*k/2 4N * k/4 8N * k/8 … 2^logk * N * k/(2^logk) =Nk Nk … Nk = O(kNlogk)

方法三：
使用隊列，將K個鏈表插入隊列，兩兩合并后放入隊尾，直到隊列中只有一個元素
實現如下:

ListNode* mergeKLists(vector<ListNode*>& lists) {if (lists.size() == 0) {return NULL;}if (lists.size() == 1) {return lists[0];}//將vector轉為隊列queue<ListNode*> waiting(deque<ListNode*>(lists.begin(), lists.end()));while(waiting.size() > 1) {ListNode *l1 = waiting.front();waiting.pop();ListNode *l2 = waiting.front();waiting.pop();ListNode *p = mergeTwoLists(l1,l2);//見如方法二中的實現waiting.push(p);}return waiting.front();
}

時間復雜度：
(k-1)*n (k - 2)*n … n = n(k-1)*k/2
O(nk^2)

總結

以上是生活随笔為你收集整理的leetcode-23 合并K个排序链表的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。