1. 程式人生 > >Leetcode 23:合併K個排序連結串列(最詳細的解法!!!)

Leetcode 23:合併K個排序連結串列(最詳細的解法!!!)

合併 k 個排序連結串列,返回合併後的排序連結串列。請分析和描述演算法的複雜度。

示例:

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

解題思路

對於多路歸併排列,我們可以使用優先佇列解決。我們首先想到的解法是,依次將list中的ListNode彈出,然後一次新增到一個優先佇列中,最後將優先佇列中ListNode依次彈出,並且新增到result中即可。

class Solution(object):
    def mergeKLists
(self, lists):
""" :type lists: List[ListNode] :rtype: ListNode """ import heapq result = ListNode(-1) cur = result p = list() for i in lists: while i: heapq.heappush(p, (i.val, i)) i = i.next while
p: cur.next = heapq.heappop(p)[1] cur = cur.next return result.next

要注意的是上述寫法只可以在python2下使用,在python3中會出現錯誤

TypeError: unorderable types: ListNode() < ListNode()

為什麼呢?

當對一個tuple排序時,python會從0開始對兩個tuple的成員依次比較,如果兩個成員相同就再比較下一個成員。問題中的tuple很有趣,前兩個連結串列的第一項比較結果都相同(1),於是python開始比較第二個成員,第二個成員是一個ListNode

,沒有比較方法,在處理這個問題上py2和py3有了差異,py2隨機瞎排,py3則是丟擲異常。

一種解決辦法是我們重寫一個ListNode,給他新增__lt__方法。我這裡使用了另外的一種解決思路,就是在tuple中再新增一個元素。( ̄▽ ̄)”

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        import heapq 
        result = ListNode(-1)
        cur = result
        p = list()
        x = 0
        for i in lists:
            while i:
                heapq.heappush(p, (i.val, x, i))
                i = i.next
                x += 1

        while p:
            cur.next = heapq.heappop(p)[1]
            cur = cur.next

        return result.next

另外我們也可以這樣做。

首先將list中的每個連結串列比較首元素,然後依次加入優先佇列(或者一個堆,我這裡使用堆)

q : 1  1  2
    |  |  |
    4  3  6
    |  |
    5  4

然後判斷這個優先佇列是否為空,不為空,我們彈出隊首元素(1),接著判斷這個彈出的元素作為一個連結串列節點,其後是否還有元素,如果有元素,將元素加入佇列。同時將結果加入到result

q : 1  2  4
    |  |  |
    3  6  5
    |
    4

result: 1

接著我們通過這個思路寫出如下程式碼

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        import heapq
        result = ListNode(-1)
        cur = result
        p = list()
        for i in lists:
            if i:
                heapq.heappush(p, (i.val, i))

        while len(p) > 0:
            cur.next = heapq.heappop(p)[1]
            cur = cur.next
            if cur.next:
                heapq.heappush(p, (cur.next.val, cur.next))

        return result.next

這裡的程式碼同樣會出現第一種情況下的問題,所以也可以按照之前的解決方法解決這個問題。

當然你可以先將所有元素加入到一個普通的佇列中,然後通過sorted(list, key=lambda x : x.val)排序,對這個排好序的list,我們還要將它串成一個連結串列。

如有問題,希望大家指出!!!

相關推薦

Leetcode 23:合併K排序連結串列詳細解法

合併 k 個排序連結串列,返回合併後的排序連結串列。請分析和描述演算法的複雜度。 示例: 輸入: [ 1->4->5, 1->3->4, 2->6 ] 輸出: 1->1->2->3->4-

leetcode 23合併K排序連結串列-----python

合併 k 個排序連結串列,返回合併後的排序連結串列。請分析和描述演算法的複雜度。 示例: 輸入: [ 1->4->5, 1->3->4, 2->6 ] 輸出: 1->1->2->3->4->4->5->6 思

leetcode 23. 合併K排序連結串列 C#

合併K個排序連結串列 Merge K Sorted Lists 思路 分治法,把k個連結串列不停的分成兩份,直到其中一份為2個連結串列或一個連結串列。2個連結串列就把這兩個連結串列合併,返回合併的連結串列。 程式碼 /** *

Leetcode(23)合併K排序連結串列

題目描述 合併 k 個排序連結串列,返回合併後的排序連結串列。請分析和描述演算法的複雜度。 示例: 輸入: [ 1->4->5, 1->3->4, 2->6 ] 輸出: 1->1->2->3->4->4->5->6 解題

LeetCode-23. 合併K排序連結串列

題目地址:https://leetcode-cn.com/problems/merge-k-sorted-lists/ 思路:歸併處理,兩兩合併,複雜度 O(log(k)*max(N)),N為連結串列長度 /** * Definition for singly-linked lis

LeetCode 23 ——合併 K 排序連結串列

1. 題目 2. 解答 2.1. 方法一 在 合併兩個有序連結串列 的基礎上,我們很容易想到第一種解法,首先我們將第一個連結串列和第二個連結串列合併成一個新的連結串列,然後再往後依次合併接下來的每個連結串列即可。 假設每個連結串列結點數一樣都為 n,第一次合併時,要遍歷 2n 個結點,往後則要分別遍歷 3

LeetCode 23 合併K排序連結串列

合併 k 個排序連結串列,返回合併後的排序連結串列。請分析和描述演算法的複雜度。 示例: 輸入: [ 1->4->5, 1->3->4, 2->6 ] 輸出:

leetcode 23. 合併K排序連結串列

題目描述:合併 k 個排序連結串列,返回合併後的排序連結串列。請分析和描述演算法的複雜度。示例:輸入: [   1->4->5,   1->3->4,   2->6 ] 輸

Leetcode做題日記:23. 合併K排序連結串列(PYTHON)

合併 k 個排序連結串列,返回合併後的排序連結串列。請分析和描述演算法的複雜度。 示例: 輸入: [ 1->4->5, 1->3->4, 2->6 ] 輸出: 1->1->2->3->4->4->5->6

23. 合併K排序連結串列

合併 k 個排序連結串列,返回合併後的排序連結串列。請分析和描述演算法的複雜度。 示例: 輸入: [ 1->4->5, 1->3->4, 2->6 ] 輸出:

23合併K排序連結串列

合併 k 個排序連結串列,返回合併後的排序連結串列。請分析和描述演算法的複雜度。 示例: 輸入: [   1->4->5,   1->3->4,   2->6 ]

21. 合併有序連結串列/23. 合併K排序連結串列

1.合併兩個有序連結串列 ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode* Phead = new ListNode(0); ListNode* l3 = Phead; while

23. 合併K排序連結串列 java 23

合併 k 個排序連結串列,返回合併後的排序連結串列。請分析和描述演算法的複雜度。 示例: 輸入: [   1->4->5,   1->3->4,   2->6 ] 輸出: 1->1->2->3->4->4->

leetCode 23. Merge k Sorted Lists (合併k排序連結串列) 解題思路和方法

Merge k Sorted Lists Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 思路:此題是由合併兩個排序連結串

[LeetCode]23. Merge k Sorted Lists合併K排序連結串列

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. Example: Input: [   1->4->5, &nb

leetcode題庫——合併k排序連結串列

題目描述: 合併 k 個排序連結串列,返回合併後的排序連結串列。請分析和描述演算法的複雜度。 示例: 輸入: [   1->4->5,   1->3->4,   2->6 ] 輸出: 1->1-&g

LeetCode23 合併k有序連結串列

解題思路: 1 之前的某道題有將兩個有序連結串列排序的解法,思路很簡單,可以拿來直接用。 2 利用分治的思想,分根據下標來分;兩兩合併,再兩兩合併…以此類推。 程式碼: /** * Definition for singly-linked list. * public

LeetCode23題:合併K有序連結串列JAVA實現

題目: 我的解答: 思路很簡單,把所有的資料先讀到ArrayList中然後轉到陣列中,然後排序,然後構建新連結串列 程式碼: /** * Definition for singly-linked list. * public class ListNode {

LeetCode 23.Merge k Sorted List 合併k有序連結串列後補

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

21 合併有序連結串列 merge two sorted lists &&23 合併k有序連結串列 merge k sorted lists

1. /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; }