当前位置： 首页 > news >正文

可视化图解算法：合并k个已排序（升序）的链表

news 来源：原创 2025/5/13 11:32:10

1. 题目

描述

合并 k 个升序的链表并将结果作为一个升序的链表返回其头节点。

数据范围：节点总数满足 0≤n≤105，链表个数满足 1≤k≤105 ，每个链表的长度满足 1≤len≤200 ，每个节点的值满足∣val∣<=1000

要求：时间复杂度 O(nlogk)

示例1

输入：

[{1,2,3},{4,5,6,7}]

返回值：

{1,2,3,4,5,6,7}

示例2

输入：

[{1,2},{1,4,5},{6}]

返回值：

{1,1,2,4,5,6}

2. 解题思路

根据题目要求，时间复杂度 O(nlogk)。如果K个升序的链表如果执行两两合并，时间复杂度（n*k^2）不满足要求。这时我们可以借助于堆（复杂度为nlogk）来完成K个链表的排序。

假如链表分别为：1→2、 1→4→5与6，合并之后为：1→1→2→4→5→6，结构如下图所示：

具体思路如下：

第一步： 定义（引用）小顶堆。

小顶堆的最小值存储于堆顶，可以完成从小到大的排序操作。

第二步：每个链表的第一个节点放入堆中。

链表的第一个节点加入到堆中之后，堆会根据链表节点的值进行堆化，将节点值最小的放到堆顶，如下图所示。

第三步：从堆中取出元素（取出的元素为节点值最小的），构成新的链表。

接下来从堆中取出堆顶的节点，并将此节点追加到新链表的末尾。节点出堆之后，它对应链表的下一个节点加入到堆中（条件是：即将加入的节点不为Null）。

从堆中取出堆顶的节点1，将它追加到新链表中去，同时1的后一个节点2入堆，加入堆之后，堆会自己进行堆化，将链表节点值最小的重新放置到堆顶。如下图所示：

之后，再从堆中取出堆顶元素1，将其追加到新链表的末尾，1的后一个节点4入堆，堆再自行进行堆化，堆顶始终保存的是节点值最小的节点，如下图所示：

一直按照此方法来操作，如果一个节点出堆，它的下一个节点为Null，则Null不入堆。这样一来最终堆中的所有节点都会被取完，如下图所示：

第四步：返回新链表的头节点。

如果堆已经空了，这时返回虚拟头结点tmpHead的下一个节点即可。

如果文字描述的不太清楚，你可以参考视频的详细讲解。

  • Python版本：哔哩哔哩_bilibilihttps://www.bilibili.com/cheese/play/ep1370261

  • Java版本：数据结构笔试面试算法-Java语言版_哔哩哔哩_bilibili数据结构笔试面试算法-Java语言版,bilibili课堂,哔哩哔哩课堂,哔哩哔哩,Bilibili,B站,弹幕https://www.bilibili.com/cheese/play/ep1366717

  • Golang版本：哔哩哔哩_bilibilihttps://www.bilibili.com/cheese/play/ep1364394

3. 编码实现

3.1 Python编码实现

from typing import List
from queue import PriorityQueue


class ListNode:
    def __init__(self, x):
        self.val = x  # 链表的数值域
        self.next = None  # 链表的指针域


# 从链表节点尾部添加节点
def insert_node(node, value):
    if node is None:
        print("node is None")
        return
    # 创建一个新节点
    new_node = ListNode(value)
    cur = node
    # 找到链表的末尾节点
    while cur.next is not None:
        cur = cur.next
    # 末尾节点的next指针域连接新节点
    cur.next = new_node


# 打印链表（从链表头结点开始打印链表的值）
def print_node(node):
    cur = node
    # 遍历每一个节点
    while cur is not None:
        print(cur.val, end="\t")
        cur = cur.next  # 更改指针变量的指向
    print()


#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param lists ListNode类一维数组
# @return ListNode类
#
class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        # write code here
        # 1. 定义（引用）小顶堆
        heap = PriorityQueue()

        # 2. 每个链表的第一个节点放入堆中
        for i in range(len(lists)):
            # 不为空则加入小顶堆
            if lists[i] is not None:
                heap.put((lists[i].val, i))  # 注意:加入的是元组（优先级,值）
                lists[i] = lists[i].next  # 移动指针变量，lists[i]执行下一个节点

        # 3. 从堆中取出元素（取出的元素为节点值最小的），构成新的链表
        tmp_head = ListNode(-1)
        cur = tmp_head
        # 从堆中取元素（节点），直到小顶堆为空
        while not heap.empty():
            # 取出最小的元素
            val, idx = heap.get()  # 注意:取出来的值也是元组，即优先级、值（优先级的值越小（优先级越高），越先取出来）
            # 节点连接
            cur.next = ListNode(val)
            cur = cur.next
            if lists[idx] is not None:
                # 取出（元素）节点的下一个节点值添加到堆中
                heap.put((lists[idx].val, idx))
                lists[idx] = lists[idx].next  # lists[i]保存下一个节点

        # 4. 返回新链表的头节点
        return tmp_head.next


if __name__ == '__main__':
    list1 = ListNode(1)
    list1.next = ListNode(2)
    print_node(list1)

    list2 = ListNode(1)
    list2.next = ListNode(4)
    list2.next.next = ListNode(5)
    print_node(list2)

    list3 = ListNode(6)
    print_node(list3)

    old_list = [list1, list2, list3]
    s = Solution()
    new_list = s.mergeKLists(old_list)
    print_node(new_list)

3.2 Java编码实现

package LL05;


import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;

public class Main {
    //定义链表节点
    static class ListNode {
        private int val;  //链表的数值域
        private ListNode next; //链表的指针域

        public ListNode(int data) {
            this.val = data;
            this.next = null;
        }
    }

    //添加链表节点
    private static void insertNode(ListNode node, int data) {
        if (node == null) {
            return;
        }
        //创建一个新节点
        ListNode newNode = new ListNode(data);
        ListNode cur = node;
        //找到链表的末尾节点
        while (cur.next != null) {
            cur = cur.next;
        }
        //末尾节点的next指针域连接新节点
        cur.next = newNode;
    }

    //打印链表（从头节点开始打印链表的每一个节点）
    private static void printNode(ListNode node) {
        ListNode cur = node;
        //遍历每一个节点
        while (cur != null) {
            System.out.print(cur.val + "\t");
            cur = cur.next; //更改指针变量的指向
        }
        System.out.println();
    }


    public static class Solution {
        /**
         * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
         *
         *
         * @param lists ListNode类ArrayList
         * @return ListNode类
         */
        public ListNode mergeKLists (ArrayList<ListNode> lists) {
            // write code here
            // 1. 定义（引用）小顶堆
            Queue<ListNode> heap = new PriorityQueue<>(new Comparator<ListNode>() {
                @Override
                public int compare(ListNode o1, ListNode o2) {
                    //默认：小顶堆
                    return o1.val - o2.val;
                }
            });

            // 2. 每个链表的第一个节点放入堆中
            //遍历所有链表第一个元素
            for (int i = 0; i < lists.size(); i++) {
                //不为空则加入小顶堆
                if (lists.get(i) != null) {
                    heap.add(lists.get(i));
                }
            }

            // 3. 从堆中取出元素（取出的元素为节点值最小的），构成新的链表
            ListNode tmpHead = new ListNode(-1);
            ListNode cur = tmpHead;
            //从堆中取元素（节点），直到小顶堆为空
            while (!heap.isEmpty()) {
                //取出最小的元素
                ListNode tmp = heap.poll();
                //节点连接
                cur.next = tmp;
                cur = cur.next;
                //取出（元素）节点的下一个节点添加到堆中
                if (tmp.next != null) {
                    heap.add(tmp.next);
                }
            }

            // 4. 返回新链表的头节点
            return tmpHead.next;
        }
    }

    public static void main(String[] args) {
        ListNode list1 = new ListNode(1);
        list1.next = new ListNode(2);
        printNode(list1);

        ListNode list2 = new ListNode(1);
        list2.next = new ListNode(4);
        list2.next.next = new ListNode(5);
        printNode(list2);

        ListNode list3 = new ListNode(6);
        printNode(list3);

        ArrayList<ListNode> lists = new ArrayList<>();
        lists.add(list1);
        lists.add(list2);
        lists.add(list3);

        Solution solution = new Solution();
        ListNode newList = solution.mergeKLists(lists);
        printNode(newList);
    }
}

3.3 Golang编码实现

package main

import (
	"container/heap"
	"fmt"
)

// ListNode 定义链表节点
type ListNode struct {
	Val  int       //链表的数值域
	Next *ListNode //链表的指针域
}

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 *
 * @param lists ListNode类一维数组
 * @return ListNode类
 */
func mergeKLists(lists []*ListNode) *ListNode {
	// write code here
	// 1. 定义（引用）小顶堆
	myHeap := &MyHeap{}
	heap.Init(myHeap)
	// 2. 每个链表的第一个节点放入堆中
	//遍历所有链表第一个元素
	for i := 0; i < len(lists); i++ {
		//不为空则加入小顶堆
		if lists[i] != nil {
			heap.Push(myHeap, lists[i])
		}
	}
	// 3. 从堆中取出元素（取出的元素为节点值最小的），构成新的链表
	tmpHead := &ListNode{Val: -1}
	cur := tmpHead
	//从堆中取元素（节点），直到小顶堆为空
	for myHeap.Len() > 0 {
		//取出最小的元素
		tmp := heap.Pop(myHeap).(*ListNode)
		//节点连接
		cur.Next = tmp
		cur = cur.Next
		//取出（元素）节点的下一个节点添加到堆中
		if tmp.Next != nil {
			heap.Push(myHeap, tmp.Next)
		}
	}
	// 4. 返回新链表的头节点
	return tmpHead.Next

}

type MyHeap []*ListNode

func (h MyHeap) Len() int {
	return len(h)
}
func (h MyHeap) Less(i, j int) bool {
	//小顶堆
	return h[i].Val < h[j].Val
}
func (h MyHeap) Swap(i, j int) {
	h[i], h[j] = h[j], h[i]

}
func (h *MyHeap) Push(v interface{}) {
	*h = append(*h, v.(*ListNode))
}
func (h *MyHeap) Pop() interface{} {
	old := *h
	n := len(old)
	v := old[n-1]
	*h = old[0 : n-1]
	return v
}
func main() {
	list1 := &ListNode{Val: 1}
	list1.Next = &ListNode{Val: 2}
	list1.Print()

	list2 := &ListNode{Val: 1}
	list2.Next = &ListNode{Val: 4}
	list2.Next.Next = &ListNode{Val: 5}
	list2.Print()

	list3 := &ListNode{Val: 6}
	list3.Print()

	lists := []*ListNode{list1, list2, list3}

	newList := mergeKLists(lists)
	newList.Print()
}

// Insert 从链表节点尾部添加节点
func (ln *ListNode) Insert(val int) {
	if ln == nil {
		return
	}
	//创建一个新节点
	newNode := &ListNode{Val: val}
	cur := ln
	//找到链表的末尾节点
	for cur.Next != nil {
		cur = cur.Next
	}
	//末尾节点的next指针域连接新节点
	cur.Next = newNode
}

// Print 从链表头结点开始打印链表的值
func (ln *ListNode) Print() {
	if ln == nil {
		return
	}
	cur := ln
	//遍历每一个节点
	for cur != nil {
		fmt.Print(cur.Val, "\t")
		cur = cur.Next //更改指针变量的指向
	}
	fmt.Println()
}

//TODO： golang heap的使用：https://golang.google.cn/pkg/container/heap/

如果上面的代码理解的不是很清楚，你可以参考视频的详细讲解。

  • Python版本：哔哩哔哩_bilibilihttps://www.bilibili.com/cheese/play/ep1370261

  • Java版本：数据结构笔试面试算法-Java语言版_哔哩哔哩_bilibili数据结构笔试面试算法-Java语言版,bilibili课堂,哔哩哔哩课堂,哔哩哔哩,Bilibili,B站,弹幕https://www.bilibili.com/cheese/play/ep1366717

  • Golang版本：哔哩哔哩_bilibilihttps://www.bilibili.com/cheese/play/ep1364394

4.小结

本题可以通过小顶堆完成，具体步骤为：

  • 定义（引用）小顶堆；

  • 每个链表的第一个节点放入堆中；

  • 从堆中取出元素（取出的元素为节点值最小的），构成新的链表；

  • 返回新链表的头节点。

难点在于小顶堆的应用。

更多算法视频讲解，你可以从以下地址找到：

  • Python编码实现：数据结构笔试面试算法-Python语言版_哔哩哔哩_bilibili数据结构笔试面试算法-Python语言版,bilibili课堂,哔哩哔哩课堂,哔哩哔哩,Bilibili,B站,弹幕https://www.bilibili.com/cheese/play/ep1509965

  • Java编码实现：数据结构笔试面试算法-Java语言版_哔哩哔哩_bilibili数据结构笔试面试算法-Java语言版,bilibili课堂,哔哩哔哩课堂,哔哩哔哩,Bilibili,B站,弹幕https://www.bilibili.com/cheese/play/ep1510007

  • Golang编码实现：数据结构笔试面试算法-Go语言版_哔哩哔哩_bilibili数据结构笔试面试算法-Go语言版,bilibili课堂,哔哩哔哩课堂,哔哩哔哩,Bilibili,B站,弹幕https://www.bilibili.com/cheese/play/ep1509945

对于链表的相关操作，我们总结了一套【可视化+图解】方法，依据此方法来解决链表相关问题，链表操作变得易于理解，写出来的代码可读性高也不容易出错。具体也可以参考视频详细讲解。

今日佳句：山重水复疑无路，柳暗花明又一村。

相关文章：

  • LeetCode——560. 和为 K 的子数组
  • 目前人工智能的发展，判断10年、20年后的人工智能发展的主要方向，或者带动的主要产业
  • 【openwebui 搭建本地知识库（RAG搭建本地知识库）】
  • 软件测试之测试用例
  • Microsoft Edge “无法更新” 解决办法
  • 学习笔记之车票搜索为什么用Redis而不是ES？
  • 32单片机——LED
  • 通过 Python 爬虫提高股票选股胜率
  • 【教学类-43-26】20240312 数独4宫格的所有可能（图片版 576套样式，空1格-空8格，每套65534张*576小图=3千万张小图）
  • 【web】网页崩溃
  • 【初级篇】如何使用DeepSeek和Dify构建高效的企业级智能客服系统
  • SVT-AV1源码分析函数 svt_av1_cost_coeffs_txb
  • 【Python入门】一篇掌握Python中的字典（创建、访问、修改、字典方法）【详细版】
  • Python使用FastAPI结合Word2vec来向量化200维的语言向量数值
  • Python爬取房天下二手小区数据(2025年3月更)
  • 布达佩斯召开 | 2025年第五届能源与环境工程国际会议(CoEEE 2025)
  • SpringBoot中使用kaptcha生成验证码
  • Spring 中 BeanPostProcessor 的作用和示例
  • Facebook投广告支付操作
  • 04 1个路由器配置一个子网的dhcp服务
  • 明查｜印度空军“又有一架战机被巴基斯坦击落，飞行员被俘”？
  • 印称印巴军事行动总指挥同意将局势降级
  • 乘联分会：上半年车市价格竞争温和，下半年价格战或再开启
  • 普京：俄中关系是国家间关系的真正典范
  • 警方通报“网约车司机偷拍女乘客”：已被行政拘留
  • 技术派｜巴基斯坦导弹：让印度保持克制的“定海神针”？