leetcode刷题记第23题解法（python解析）（合成K个有序链表）

题目定义

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

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

来源：力扣（LeetCode）
链接: leetcode_23题.

1. 暴力解决（列表）

直接将其装换为列表，然后对列表排序，最后将列表转为链表

2. 优先队列

heapq 这个库

3. 分治法

另一个

4. 分治法的优化

===================================================

实现

// An highlighted block
# Definition for singly-linked list.
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
    def mergeKLists(self, lists):
        '''

        方法 1：暴力

        遍历所有链表，将所有节点的值放到一个数组中。
        将这个数组排序，然后遍历所有元素得到正确顺序的值。
        用遍历得到的值，创建一个新的有序链表

        '''

        if len(lists)<1:
            return []

        list_all = []
        for l in lists:

            while l:
                list_all.append(l.val)
                l = l.next

        print(list_all)
        list_all.sort()

        res = ListNode(0)
        exc = res
        # 将相同的拼进去
        for i in list_all:
            node = ListNode(i)
            exc.next = node
            exc = exc.next

        return res.next

    def mergeKLists_1(self, lists) :
        '''优先级队列'''
        import heapq
        dummy = ListNode(0)
        p = dummy
        head = []
        for i in range(len(lists)):
            if lists[i]:
                heapq.heappush(head, (lists[i].val, i))
                lists[i] = lists[i].next
        while head:
            val, idx = heapq.heappop(head)
            p.next = ListNode(val)
            p = p.next
            if lists[idx]:
                heapq.heappush(head, (lists[idx].val, idx))
                lists[idx] = lists[idx].next
        return dummy.next

    def mergeKLists_2(self, lists):
        '''分治法   将前后相加'''

        # 最暴力的解法
        # amount = len(lists)  # 列表的长度
        # if amount<1:
        #     return None
        # l = lists[0]
        # for i in range(amount-1):
        #     l = self.merge2List(l,lists[i+1])
        # return l
        # 将暴力解法优化后的算法
        amount = len(lists)  # 列表的长度
        if amount<1:
            return None
        while amount>1:
            for  i in range(amount//2):
                lists[i] = self.merge2List(lists[i],lists[amount-1-i])
            amount = (amount+1)//2

        return lists[0]


    def mergeKLists_3(self, lists):
        #将暴力解法优化后的算法
        # 这个和2是一样的  只是这个是相邻的两个相加
        amount = len(lists)   # 列表的长度
        interval = 1  # 下一个
        if amount<1:
            return None
        while interval<amount:
            for i in range(0,amount-interval,interval*2):
                lists[i] = self.merge2List(lists[i],lists[i+interval])
            interval*=2
        return lists[0] if amount>0 else lists

    def merge2List(self,l1, l2):
        if l1 is None or l2 is None:
            return l1 if l1 else l2
        head = ListNode(0)
        point = head
        while l1 and l2:
            if l1.val <= l2.val:
                point.next = l1
                l1 = l1.next
                point = point.next
            else:
                point.next = l2
                l2 = l2.next
                point = point.next

        if l1:
            point.next = l1

        else:
            point.next = l2

        return head.next


    def print_node(self,node):
        '''
        遍历链表
        '''
        while node:
            print(node.val)
            node = node.next

a = ListNode(1)
b = ListNode(4)
c = ListNode(5)
d = ListNode(1)
e = ListNode(3)
f = ListNode(4)
g = ListNode(2)
h = ListNode(6)


a.next = b
b.next = c
# c.next = d
d.next = e
e.next = f

g.next = h



s = Solution()

res = s.mergeKLists_2([a,d,g])

s.print_node(res)