力扣题解 23 .合并升序链表 -—python中堆的使用

堆的简单实用

在Python中，可以使用heapq模块来实现堆的操作。heapq模块提供了一些函数来操作堆，包括将列表转换为堆、向堆中插入元素、从堆中弹出最小元素等。
下面是一些常用的堆操作示例：
1. 创建一个堆：

import heapq

heap = []  # 创建一个空堆

heapq.heapify(heap)  # 将列表转换为堆

2. 向堆中插入元素：

heapq.heappush(heap, item)  # 向堆中插入元素item

3. 从堆中弹出最小元素：

min_item = heapq.heappop(heap)  # 弹出堆中的最小元素

4. 获取堆中的最小元素（不弹出）：

min_item = heap[0]  # 获取堆中的最小元素

5. 合并多个堆：

merged_heap = heapq.merge(heap1, heap2)  # 合并多个堆，返回一个新的堆

6. 获取堆的大小：

heap_size = len(heap)  # 获取堆的大小

这些是一些基本的堆操作，你可以根据具体的需求使用这些函数来实现堆的功能。

接下来我将用一道力扣题来帮大家演示，这里用到了小根堆的建立

题目描述

23. 合并 K 个升序链表
给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。
示例 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
示例 2：
输入：lists = []
输出：[]
示例 3：
输入：lists = [[]]
输出：[]

题解：
1. 首先，导入heapq模块，用于处理小根堆。
2. 创建一个空的小根堆h。
3. 使用两个嵌套的循环，外层循环遍历链表列表lists，内层循环遍历每个链表的节点。
4. 在内层循环中，将每个节点的值加入小根堆h中，使用heapq.heappush()函数。
5. 创建一个虚拟节点dummy和一个指针add，用于构建合并后的链表。
6. 使用一个循环，循环次数为小根堆h的长度，每次循环将add指向小根堆中堆顶元素（最小值）
7. 将add指针向后移动一位。
8. 最后，返回合并后的链表的头节点dummy.next。

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        # 使用堆处理 小根堆 不断弹出堆顶元素，加入列表
        import heapq
        h=[]
        for l in lists:
            while l:
                heapq.heappush(h,l.val)
                l=l.next
        add = dummy = ListNode(0)
        for _ in range(len(h)):
            # ListNode(heapq.heappop(h))  为最小值在节点
            add.next = ListNode(heapq.heappop(h))
            add = add.next
        return dummy.next

当然还有一种很繁琐的解，供大家参考

首先将，列表中的链表合并为一个链表，然后对其使用折半排序

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        l=self.total(lists)
        add=dummy=ListNode(0)
        i=l1=ListNode(0)
        j=l2=ListNode(0)
        for _ in range(int(len(l)/2)):
            i.next=l
            l=l.next
            i=i.next
            j=j.next
        for _ in range(int(len(l)/2),len(l)):
            j.next=l
            l=l.next
            j=j.next
        while l1 and l2:
            if l1.val<l2.val:
                add.next=l1
                l1=l1.next
            else:
                add.next=l2
                l2=l2.next
        add.next=l1 or l2
        return dummy.next
    def total(self,lists):
        dummy=ListNode(0)
        i=dummy
        for x in lists:
            while x:
                i.next=x
                x=x.next
                i=i.next
        return dummy.next
Definition for singly-linked list.
class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next