打印节点(链表或者二叉树)工具

原创 已于 2025-07-27 13:16:19 修改 · 858 阅读 · 20 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#链表 #数据结构 #leetcode
于 2025-07-27 13:11:24 首次发布

目录

1. 背景与目的：方便排查问题

2. 效果 

3. 工具类代码

3.1 链表数据结构定义

3.2 二叉树数据结构定义 

3.3 工具类代码

3.3.1 注意事项

4. 使用示例 

4.1 题目：leetcode第700题：二叉搜索树中的搜索

4.1.1 题目介绍

 4.1.2 代码

4.1.3 控制台 

4.2 题目：leetcode第148题：排序链表

4.2.1 题目介绍

4.2.2 代码

4.2.3 控制台

1. 背景与目的：方便排查问题

在leetcode刷题中，当出现链表题或者二叉树的题目的时候

给出的输入和输出示例通常是数组形式, 如图所示：

这样很不清晰，不知道自己返回的结构到底是怎么样的，如果能够打印出合适的格式，会方便我们排查问题。

leetcode给出的输入与输出示例都不太直观：

如下先给出两种数据结构题型的示例：

链表结构：

 二叉树结构：

2. 效果 

我们首先给出工具的效果：

给出的示例比较简单：

下文给出更详细的示例。

3. 工具类代码

首先创建一个包: definition, 用于定义链表节点和树节点：

如何定义都和leetcode上面保持一致，可以放心导入。

3.1 链表数据结构定义

package definition;

/**
 * @author: Rehse
 * @description: 定义链表结构
 * @time: 2025/7/27 12:08
 */
public class ListNode {
    public int val;
    public ListNode next;

    public ListNode() {
    }

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

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

}

3.2 二叉树数据结构定义 

package definition;

/**
 * @author: Rehse
 * @description: 定义二叉树结构
 * @time: 2025/7/27 12:08
 */
public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;

    TreeNode() {
    }

    public TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

3.3 工具类代码

这个工具类定义在预先定义的工具类包utils下面，不需要的话就删掉，或者改喜欢的名字。

工具类下面有main函数, 可以打印出示例康康。

package utils;
// 导入链表和二叉树数据结构类

import definition.ListNode;
import definition.TreeNode;

import java.util.*;

/**
 * @author: Rehse
 * @description: 打印工具类
 * @time: 2025/7/27 12:10
 */
public class PrintUtils {
    /**
     * 根据传入数组参数 构建链表
     */
    public ListNode listNode;
    public TreeNode treeNode;

    /**
     * 有时候 leetcode给出的示例的某个null值, 这里用Integer的最小值来代替null节点
     */
    static final int NULL = Integer.MIN_VALUE;

    /**
     * 节点类型: 0->链表, 1->树
     */
    public static int type;
    /**
     * 节点类型: 链表
     */
    public static final int NODE_TYPE_LINKED = 0;
    /**
     * 节点类型: 树
     */
    public static final int NODE_TYPE_TREE = 1;

    /**
     * 空节点用字符串"null"表示
     */
    private static final String NULL_SYMBOL = "null";

    /**
     * @return ListNode
     * @author: Rehse
     * @description: 返回链表结构
     * @time: 2025/7/27 11:50
     */
    public ListNode getListNode() {
        return this.listNode;
    }

    /**
     * @return ListNode
     * @author: Rehse
     * @description: 返回二叉树结构
     * @time: 2025/7/27 11:50
     */
    public TreeNode getTreeNode() {
        return this.treeNode;
    }

    /**
     * @return void
     * @author: Rehse
     * @description: 构造函数: 根据传入的数组和类型(0: 链表, 还是1: 树)构造工具类
     * @param[1] nums
     * @param[2] type
     * @time: 2025/7/27 10:25
     */
    public PrintUtils(int[] nums, int type) {
        this.type = type;
        if (type == NODE_TYPE_LINKED) {
            listNode = new ListNode(nums[0]);
            ListNode cur = listNode;
            for (int i = 1; i < nums.length; i++) {
                cur.next = new ListNode(nums[i]);
                cur = cur.next;
            }
            cur.next = null;
        } else if (type == NODE_TYPE_TREE) {
            Queue<TreeNode> queue = new ArrayDeque<>();
            treeNode = new TreeNode(nums[0]);
            queue.offer(treeNode);
            for (int index = 1; index < nums.length; index++) {
                TreeNode node = queue.poll();
                if (index < nums.length && nums[index] != NULL) {
                    node.left = new TreeNode(nums[index]);
                    queue.offer(node.left);
                }
                index++;
                // 右子节点
                if (index < nums.length && nums[index] != NULL) {
                    node.right = new TreeNode(nums[index]);
                    queue.offer(node.right);
                }
            }
        } else {
            throw new IllegalArgumentException("非法的type参数，必须是0(链表)或1(树)");
        }
    }


    /**
     * @return void
     * @author: Rehse
     * @description: 自动根据类型打印链表或者树
     * @time: 2025/7/27 10:16
     */
    public void print() {
        if (type == NODE_TYPE_LINKED) {
            printListNode(listNode);
        } else {
            printTree(treeNode);
        }
    }

    /**
     * @return void
     * @author: Rehse
     * @description: 打印链表
     * @param[1] head
     * @time: 2025/7/27 10:16
     */
    public static void printListNode(ListNode head) {
        System.out.println("打印链表：");
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val + "->");
            cur = cur.next;
        }
        System.out.print("null\n");
        System.out.println("-----------------------------------------------------------------------------------------");
    }

    /**
     * @return void
     * @author: Rehse
     * @description: 打印树 分层地打印出来 可打印出空节点
     * @param[1] root
     * @time: 2025/7/27 10:16
     */
    public static void printTree(TreeNode root) {
        System.out.println("打印树:");
        if (root == null) {
            System.out.println("树为空");
            return;
        }
        int height = getHeight(root);
        int maxValLength = getMaxValueLength(root);
        int spaceWidth = maxValLength + 2; // 每个节点的显示宽度

        List<List<String>> levels = new ArrayList<>();
        buildLevels(root, height, maxValLength, levels);

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < levels.size(); i++) {
            List<String> level = levels.get(i);
            int leadingSpace = (int) (spaceWidth * Math.pow(2, height - i - 1) - spaceWidth / 2);
            sb.append(" ".repeat(leadingSpace));

            for (String node : level) {
                sb.append(node).append(" ".repeat(spaceWidth * (int) Math.pow(2, height - i) - spaceWidth));
            }
            sb.append("\n");
        }
        System.out.print(sb);
        System.out.println("-----------------------------------------------------------------------------------------");
    }

    /**
     * @return void
     * @author: Rehse
     * @description: 构建树层
     * @param[1] node
     * @param[2] height
     * @param[3] maxLen
     * @param[4] levels
     * @time: 2025/7/27 11:19
     */

    private static void buildLevels(TreeNode node, int height, int maxLen, List<List<String>> levels) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(node);
        for (int i = 0; i < height; i++) {
            int levelSize = queue.size();
            List<String> currentLevel = new ArrayList<>();

            for (int j = 0; j < levelSize; j++) {
                TreeNode curr = queue.poll();
                if (curr == null) {
                    currentLevel.add(String.format("%" + maxLen + "s", NULL_SYMBOL));
                    queue.offer(null);
                    queue.offer(null);
                } else {
                    currentLevel.add(String.format("%" + maxLen + "d", curr.val));
                    queue.offer(curr.left);
                    queue.offer(curr.right);
                }
            }
            levels.add(currentLevel);
        }
    }

    /**
     * @return int
     * @author: Rehse
     * @description: 获取树的高度
     * @param[1] root
     * @time: 2025/7/27 11:19
     */
    private static int getHeight(TreeNode root) {
        if (root == null) return 0;
        return 1 + Math.max(getHeight(root.left), getHeight(root.right));
    }

    /**
     * @return int
     * @author: Rehse
     * @description: 获取最大数值的长度
     * @param[1] root
     * @time: 2025/7/27 11:19
     */
    private static int getMaxValueLength(TreeNode root) {
        if (root == null) return 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int maxLength = 0;

        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node != null) {
                // 计算当前节点值的字符串长度（考虑负数）
                int currentLength = String.valueOf(node.val).length();
                maxLength = Math.max(maxLength, currentLength);

                queue.offer(node.left);
                queue.offer(node.right);
            }
        }
        return maxLength;
    }

    /**
     * @return void
     * @author: Rehse
     * @description: 获取节点并打印
     * @time: 2025/7/27 12:39
     */
    public void getAndPrint() {
        if (type == NODE_TYPE_LINKED) {
            ListNode listNode = this.getListNode();
        } else {
            TreeNode treeNode = this.getTreeNode();
        }
        this.print();
    }

    /**
     * @author: Rehse
     * @description: 使用示例
     * @param[1] args
     * @time: 2025/7/27 10:14
     */
    public static void main(String[] args) {
        PrintUtils utils1 = new PrintUtils(new int[]{1, 2, 3, 4, 5}, 0);
        utils1.print();
        PrintUtils utils2 = new PrintUtils(new int[]{1, 2, 3, 4, 5}, 1);
        utils2.print();
        PrintUtils utils3 = new PrintUtils(new int[]{1, 2, 3, 4, NULL, 5}, 1);
        utils3.print();
        PrintUtils utils4 = new PrintUtils(new int[]{1, 2, 3, 4, NULL, 5, 6, 7, 8, 9}, 1);
        utils4.print();
        PrintUtils utils5 = new PrintUtils(new int[]{1, 2, 3, 4, NULL, 5, 6, 7, 8, 9}, 2);
        utils5.print();
    }
}

3.3.1 注意事项

如上代码块中的main函数,

先通过一个数组以及一个type参数(0代表链表，1代表二叉树)构造工具类。

然后调用工具类对象的print()方法即可

注：在leetcode有些二叉树的题在给出的输入示例总是会出现空节点, 用null来表示的

在工具类代码中用一个静态常量NULL来作为替代，

这个NULL值为Integer.MIN_VALUE，

在构造工具类前可以预先定义一下：

static final int NULL = Integer.MIN_VALUE;

在控制台中的效果如下：

type只能是0(链表)或者1(二叉树), 否则抛出异常

4. 使用示例 

我在做题的时候一般是这样用的：

4.1 题目：leetcode第700题：二叉搜索树中的搜索

4.1.1 题目介绍

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

示例 1:

输入：root = [4,2,7,1,3], val = 2
输出：[2,1,3]

 4.1.2 代码

在main函数里面调用这道题中的函数的时候 先将函数返回类型前面加上static字段。

完整代码如下：

package leetcode.tree;

import definition.TreeNode;
import utils.PrintUtils;

/**
 * @author: Rehse
 * @description: 二叉搜索树中的搜索
 * @date: 2025/7/27
 */
public class Leetcode_700_SearchInABinarySearchTree {
    /**
     * @author: Rehse
     * @description: 递归
     * @param[1] root
     * @param[2] val
     * @return TreeNode
     * @time: 2025/7/27 12:17
     */
    public static TreeNode searchBST(TreeNode root, int val) {
        if (root == null) {
            return null;
        }
        if (val == root.val) {
            return root;
        }
        return searchBST(val < root.val ? root.left : root.right, val);
    }

    public static void main(String[] args) {
        // 1.可以根据数组构造工具类 第二个参数为1 代表这是树结构
        PrintUtils utils = new PrintUtils(new int[]{4, 2, 7, 1, 3}, 1);
        // 2.通过工具类返回这个二叉树的结构
        TreeNode root = utils.getTreeNode();
        // 3.通过工具类对象可以打印出来本题示例看看 这个print()则是根据节点类型type自动调用第5条的打印树的函数
        utils.print();
        // 第2步和第3步 可以只用下面这个函数 合并了两个操作 得到并打印
        // utils.getAndPrint();
        // 4.调用本题函数 返回一个结果树
        TreeNode resultTree = searchBST(root, 2);
        // 5.通过工具类的静态函数.打印树, 打印出这个结果树的结构
        PrintUtils.printTree(resultTree);
    }

}

4.1.3 控制台 

这道题有点简单，返回的结果子树也比较简单，读者可以用更复杂的题试试。

4.2 题目：leetcode第148题：排序链表

4.2.1 题目介绍

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

示例 ：

输入：head = [-1,5,3,4,0]
输出：[-1,0,3,4,5]

    4.2.2 代码

    在main函数里面调用这道题中的函数的时候 先将函数返回类型前面加上static字段。

    完整代码如下：

    package leetcode.linkedlist;

import definition.ListNode;
import utils.PrintUtils;

/**
 * @author: Rehse
 * @description: 排序链表
 * @date: 2025/7/27
 */
public class Leetcode_148_SortList {
    public static ListNode sortList(ListNode head) {
        return sortList(head, null);
    }

    public static ListNode sortList(ListNode head, ListNode tail) {
        if (head == null) {
            return head;
        }
        if (head.next == tail) {
            head.next = null;
            return head;
        }
        ListNode slow = head, fast = head;
        while (fast != tail) {
            slow = slow.next;
            fast = fast.next;
            if (fast != tail) {
                fast = fast.next;
            }
        }
        ListNode mid = slow;
        ListNode list1 = sortList(head, mid);
        ListNode list2 = sortList(mid, tail);
        ListNode sorted = merge(list1, list2);
        return sorted;
    }

    public static ListNode merge(ListNode head1, ListNode head2) {
        ListNode dummyHead = new ListNode(0);
        ListNode temp = dummyHead, temp1 = head1, temp2 = head2;
        while (temp1 != null && temp2 != null) {
            if (temp1.val <= temp2.val) {
                temp.next = temp1;
                temp1 = temp1.next;
            } else {
                temp.next = temp2;
                temp2 = temp2.next;
            }
            temp = temp.next;
        }
        if (temp1 != null) {
            temp.next = temp1;
        } else if (temp2 != null) {
            temp.next = temp2;
        }
        return dummyHead.next;
    }

    public static void main(String[] args) {
        // 1.可以根据数组构造工具类 第二个参数为0 代表这是链表结构
        PrintUtils utils = new PrintUtils(new int[]{-1,5,3,4,0}, 0);
        // 2.通过工具类返回这个二叉树的结构
        ListNode head = utils.getListNode();
        // 3.通过工具类对象可以打印出来本题示例看看 这个print()则是根据节点类型type自动调用第5条的打印树的函数
        utils.print();
        // 第2步和第3步 可以只用下面这个函数 合并了两个操作 得到并打印
        // utils.getAndPrint();
        // 4.调用本题函数 返回一个链表
        ListNode result = sortList(head);
        // 5.通过工具类的静态函数.打印链表, 打印出这个结果链表的结构
        PrintUtils.printListNode(result);
    }
}

    4.2.3 控制台

    屎山代码仅供参考，觉得我拉的屎有用的话，点个赞么么哒！

    二叉树-7.1 二叉树序列打印
    Iamlzm的博客
    04-14 1119
    在前序遍历中，我们每遍历到一个结点，当即把它打印出来，然后把它的左孩子压入栈中，遇到空结点时，把退栈得到栈顶元素x，然后x的右子树按上面做法继续压入栈中。观察递归做法中的前序遍历，可以发现：我们每遍历一个结点，当即打印出该结点，然后以左孩子，右孩子的顺序接着往下递归。一种通用的迭代解法。按照这个顺序，1入栈，2入栈，2出栈并打印，3入栈，3出栈并打印，轮到1时，因为它还有右子树，所以要把3再次入栈，这样就会重复打印3了，所以要使用一个栈打印结点值，除了记录当前正在遍历的结点，还要记录之前已经访问过的结点。
    【C语言】打印二叉树树形（制表符实现，清晰+高拓展）（2022-10-22 更新—偏移量说明）
    热门推荐
    Ice__Clean的博客
    11-01 1万+
    —— 目录 ——0. 前言1. 效果展示2. 核心代码及解读3. 辅助代码 0. 前言 上 CSDN 找了很多份树形代码，一个共通的感觉就是拓展性不够强 比如说树大了节点之间被撑开无法兼容性不好 没有使用树枝连接的画显示稍显混乱，使用斜线当树枝又不好拓展 还有一部分就是代码太冗长看不懂 基于此，我打算用回制表符，力求清晰显示出树形 肝了几个小时的代码，过程中一点一点调出来树形 代码部分也在不断优化，思路在不断的调试中也不断改变 最后总结出一种以绝对偏移量画树形的方法，下边将一一对代码进行解释 1. 效果展
    如何用fastai实现行星数据集多标签识别：从入门到实战的完整指南
    最新发布
    gitblog_00064的博客
    05-04 364
    多标签分类是计算机视觉领域的重要任务，尤其在遥感图像分析中具有广泛应用。本文将详细介绍如何使用fastai深度学习库，以行星亚马逊数据集为例，实现高效的多标签图像识别。通过本教程，即使是深度学习新手也能快速掌握多标签分类的核心技术和实战技巧。 ## fastai多标签分类的核心优势 fastai作为一款强大的深度学习库，在处理多标签分类任务时展现出独特优势。其分层API设计让开发者可以根据需求
    打印二叉树 - java实现
    JokerBee的博客
    07-04 734
    二叉树打印
    打印一棵二叉树（详细版）
    unbelieveme的博客
    03-12 1万+
    打印一棵二叉树 二叉树：是一种重要的树状数据结构，通常由根节点，左子树和有子树构成，其中除叶子节点以外，每一个节点最少含有一个分支节点，最多含有两个分支节点。正是由于这种特殊的性质，使得二叉树在数据存储，数据排序以及顺序查找当中有重大的应用。 ①节点：包含一个数据元素及若干指向子树分支的信息 ②节点的度：一个节点拥有子树的数目称为节点的度 ③叶子节点：也称为终端节点，没有子树的节点或者度为零的节点 ④分支节点：也称为非终端节点，度不为零的节点称为非终端节点 ⑤树的度：树中所有节点的度的最大值 ⑥节点的层次
    数据结构--建立与输出二叉树
    m0_62476845的博客
    04-01 6481
    建立与输出二叉树--C语言实现太多了不会？跟着我的代码敲，熟能生巧，一个一个模块去做，分治法大事化小。看着代码自己打一遍，能运行就是成功。
    Java 实现从上往下打印出二叉树的每个节点，同层节点从左至右打印。
    MJ_911的博客
    03-28 973
    思路： 思路很明确，将节点和节点存储的值分别依次存入链表。 public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) { ArrayList<Integer> intList = new ArrayList<Integer>(); ArrayList<TreeNode> t...
    ACM模式下链表、二叉树的输入Python实现
    weiyaner的博客
    04-24 5714
    ACM模式，通过数组生成二叉树
    链表实现 二叉树
    欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
    08-30 2408
    链表实现二叉树
    根据输入创建得到一棵二叉树或者单链表
    zz2230633069的博客
    05-04 1153
    python创建链表 class SingleNode(object): # 默认是object，下面的类也同理，可使用class SingleNode: def __init__(self,value): self.val=value self.next=None # 创建单链表 class LinkedList(object): def _...
    按照树形结构直观地打印出一棵二叉树(Java)
    04-28 4149
    平时无论是工作还是学习中，在写代码时，树总是一个非常常见的数据结构。在我们完成一棵树的构建之后，如果我们想要看这棵树的结构...
    如何打印链表
    公众号：风景邮递Yuan的博客
    12-23 2168
    Status list_print(LinkedList head){ if(head==NULL){ return ERROR; } LinkedList p=head->next; while(p!=NULL){ printf("%d",p->data); p=p->next; } } ...
    【数据结构实验】简单打印二叉树超详细讲解（含二叉树每一个元素所在层数的算法和求二叉树深度的代码）
    亿维数组's博客
    05-22 2735
    问题描述 打印二叉树结构（设计性实验） 问题描述 按凹入表形式横向打印二叉树结构，即二叉树的根在屏幕的最左边，二叉树的左子树在屏幕的下 边，二叉树的右子树在屏幕的上边。例如： 测试数据 由读者依据软件工程的测试技术自己确定。注意测试边界数据，如空二叉树。 实验分析 首先观察例子中打印的二叉树的排版格式，如果把图片顺时针旋转90度，就能看到非常直观的二叉树的排版，现在需要从中找到规律，从而用代码将其实现。 经过观察发现： 打印出的二叉树中，每一行可以看成只有一个元素，最.
    从上到下打印二叉树
    Bzdjsmz的博客
    07-27 296
    建立一个vector数组ret用来当做返回的结果数组，建立一个队列用来接收二叉树的内容，当队列不为空时，取出队列的队头元素temp，将其val数值压入结果数组中，然后再将该队列队头元素弹出，最后依次访问temp的左右子树，若不为空，压入队列中，进行下一步的判断和结果数组的压入。从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。给定二叉树: [3,9,20,null,null,15,7],
    使用python打印一棵二叉树
    unbelieveme的博客
    02-06 3977
    使用python打印一棵二叉树 打印出一棵二叉树的形状，适合平时的学习，但是存在一个bug # 构建二叉树 class Node: '节点类型' def __init__(self, item): self.item = item self.left = None self.right = None class Tree: '二叉树' def __init__(self): self.root = Non
    数据结构——二叉树
    qq_41934502的博客
    05-28 1380
    二叉树的一些基本操作
    构建一颗二叉树，并将其打印出来（c++实现）
    qq_37795916的博客
    03-26 2944
    求树的深度打印树感觉太繁琐了，直接拿去用就行，不需要知道细节。
    打印二叉树
    Bug_ancestor的博客
    01-16 3711
    概述 该程序是根据先序序列打印二叉树，如果先序遍历过程中下一个结点为空结点则用空格表示。程序源码在最后。 实现思路 首先想到要把二叉树打印出来，最简单的表现形式是把一个层序遍历（代码中的tree字符串）的二叉树打印；首先实现这个功能（程序中print_BiTree函数中init_str(str, 0, 0, strlen(str));之后的部分），实现这个功能需要首先对布局有一定的判断，即如何能将任意深度的二叉树都堆成的摆在一个平面上； 例如：不管是打印深度3还是深度5都保证整个图形的对称。 2.
    二叉树的树状打印（Java）
    Myd
    07-27 5033
    树型结构的打印难点是如何处理好同一行不同节点之间的位置关系，空格和连接线的位置长度；只要弄清楚这些就可以写代码了。
    【二叉树】多行打印二叉树和按之字形打印二叉树
    菜鸟成长记
    08-11 515
    问题一问题描述 从上到下按层打印二叉树，同层的从左到右打印。打印多行。分析：可以想到层次遍历，借助队列存储结点；但是要打印成多行，所以必须设计两个变量，来表示当前打印的行的个数，和下一行打印的个数。void PrintBinaryTree(Node* pRoot) { if (pRoot == NULL) return; queue<Node*> q; q.
    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

    当前余额3.43元 前往充值 >
    需支付：10.00元
    成就一亿技术人!
    领取后你会自动成为博主和红包主的粉丝 规则
    hope_wisdom
    发出的红包
    实付元
    使用余额支付
    点击重新获取
    扫码支付
    钱包余额 0

    抵扣说明：

    1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
    2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

    余额充值