按照树形结构直观地打印出一棵二叉树、快速创建leetcode中树的结构(Java)

置顶 已于 2024-03-14 10:45:27 修改
阅读量1.5k 收藏 8
点赞数 4
分类专栏： 算法 文章标签： java leetcode 算法 TreeNode打印 TreeNode字符串转化
于 2023-03-16 23:00:00 首次发布
wang hai xin
本文链接：https://blog.csdn.net/qq_44850489/article/details/129557959
版权

前言

文章最后附上的完整代码，可以放到项目里做处理TreeNode（树）结构的工具类，包括字符串转TreeNode，和可视化打印TreeNode。

平时无论是工作还是学习中，在写代码时，树总是一个非常常见的数据结构。在我们完成一棵树的构建之后，如果我们想要看这棵树的结构，不像数组或者List等数据结构，我们可以非常方便地用各种方式将其中的所有元素打印出来，对于树而言，这个过程要麻烦得多，我们可以用各种遍历方式得到这棵树的结构，但是终究还是不够直观。

不知大家有没有想过，如果我们可以按照树的结构，将其打印出来就好了，那么本文就是一种实现这个目标的思路以供参考。

我是在做leetcode的 [236]二叉树的最近公共祖先 Medium 2023-02-13 185 时写的此文章，下面就用这道题目做实例。

按照树形结构直观地打印出一棵二叉树Java

1 效果图

引入文章结尾的工具类之后，生成和打印TreeNode，只需要
三行代码：

public class P236_LowestCommonAncestorOfABinaryTree{
	 public static void main(String[] args) {

        String s = "[3,5,1,6,2,0,8,null,null,7,4]";
         TreeNode treeNode = TreeNode.mkTree(s);
         TreeNode.show(treeNode);
         }
         }

效果图：

            3            
         /     \         
      5           1      
    /   \       /   \    
  6       2   0       8  
         / \             
        7   4

2 树的结构

在本文中所用的树的结构是leetcode上所用的树的结构，其定义如下：

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int x) { val = x; }
}

3 如何方便地创建一个树的数据结构？

leetcode里总是通过"[3,9,20,null,null,15,7]" 来表示一棵树，
可以直接把这个方法放到树操作的工具类里。之后调试创建树的时候就可以一键生成啦！！

    /**
     * description: strToTree
     * // String str = "[3,9,20,null,null,15,7]";
     * @author Wang Hai Xin
     * @date 2023/3/22 17:10
     * 
     * @param str
     * @return cn.wanghaixin.solution.utils.TreeNode
     */
    public static TreeNode strToTree(String str) {

        Integer[] integers = stringToArray(str);

        TreeNode treeNode = constructTree(integers);
        return treeNode;
    }

    /**
     * description: constructTree将数组转化为二叉树
     * @author Wang Hai Xin
     * @date 2023/3/22 17:11
     * 
     * @param array
     * @return cn.wanghaixin.solution.utils.TreeNode
     */
    public static TreeNode constructTree(Integer[] array) {
        if (array == null || array.length == 0 || array[0] == null) {
            return null;
        }

        int index = 0;
        int length = array.length;

        TreeNode root = new TreeNode(array[0]);
        Deque<TreeNode> nodeQueue = new LinkedList<>();
        nodeQueue.offer(root);
        TreeNode currNode;
        while (index < length) {
            index++;
            if (index >= length) {
                return root;
            }
            currNode = nodeQueue.poll();
            Integer leftChild = array[index];
            if (leftChild != null) {
                currNode.left = new TreeNode(leftChild);
                nodeQueue.offer(currNode.left);
            }
            index++;
            if (index >= length) {
                return root;
            }
            Integer rightChild = array[index];
            if (rightChild != null) {
                currNode.right = new TreeNode(rightChild);
                nodeQueue.offer(currNode.right);
            }
        }

        return root;
    }

涉及到的将str转化为array
stringToArray

    /**
     * description: stringToArray 将数字类型的字符数组转化为 int类型的数组
     *
     * @param data
     * @return java.lang.Integer[]
     * @author Wang Hai Xin
     * @date 2023/1/12 18:28
     */

    public static Integer[] stringToArray(String data) {
        data = data.substring(1, data.length() - 1).trim();

        String[] split = data.split(",");
        int len = split.length;
        Integer[] res = new Integer[len];
        for (int i = 0; i < len; i++) {

            if (split[i].equals("null")) {
                res[i] = null;

            } else {
                res[i] = Integer.parseInt(split[i].trim());

            }


        }
        return res;
    }

4 如何打印一棵树

在这里，我的总体思路是，用一个二维的字符串数组来储存每个位置应该打印什么样的输出。

首先，先确定树的形状。为了美观，我设定在最后一行的每个数字之间的间隔为3个空格，而在之上的每一层的间隔，有兴趣的同学可以自己推算一下，总之，越往上，间隔是越大的，而且是一个简单的线性增加的关系。

为了绘制出这样的形状，首先，我们需要获得树的层数（用一个简单的递归即可得到），根据树的层数，确定我们的二维数组的大小，即高度和宽度。之后，用先序遍历的方式，遍历树的每个节点，并进行相对应的写入操作。

更详细的解释可以看代码中的注释，当然，也可以根据下面TreeNode.java中的demo直接在自己的代码中调用这个方法来检查自己的树。

话不多说，直接贴上所用的代码：

 /*
    树的结构示例：
              1
            /   \
          2       3
         / \     / \
        4   5   6   7
    */

    // 用于获得树的层数
    public static int getTreeDepth(TreeNode root) {
        return root == null ? 0 : (1 + Math.max(getTreeDepth(root.left), getTreeDepth(root.right)));
    }



    private static void writeArray(TreeNode currNode, int rowIndex, int columnIndex, String[][] res, int treeDepth) {
        // 保证输入的树不为空
        if (currNode == null) return;
        // 先将当前节点保存到二维数组中
        res[rowIndex][columnIndex] = String.valueOf(currNode.val);

        // 计算当前位于树的第几层
        int currLevel = ((rowIndex + 1) / 2);
        // 若到了最后一层，则返回
        if (currLevel == treeDepth) return;
        // 计算当前行到下一行，每个元素之间的间隔（下一行的列索引与当前元素的列索引之间的间隔）
        int gap = treeDepth - currLevel - 1;

        // 对左儿子进行判断，若有左儿子，则记录相应的"/"与左儿子的值
        if (currNode.left != null) {
            res[rowIndex + 1][columnIndex - gap] = "/";
            writeArray(currNode.left, rowIndex + 2, columnIndex - gap * 2, res, treeDepth);
        }

        // 对右儿子进行判断，若有右儿子，则记录相应的"\"与右儿子的值
        if (currNode.right != null) {
            res[rowIndex + 1][columnIndex + gap] = "\\";
            writeArray(currNode.right, rowIndex + 2, columnIndex + gap * 2, res, treeDepth);
        }
    }


    public static void show(TreeNode root) {
        if (root == null) System.out.println("EMPTY!");
        // 得到树的深度
        int treeDepth = getTreeDepth(root);

        // 最后一行的宽度为2的（n - 1）次方乘3，再加1
        // 作为整个二维数组的宽度
        int arrayHeight = treeDepth * 2 - 1;
        int arrayWidth = (2 << (treeDepth - 2)) * 3 + 1;
        // 用一个字符串数组来存储每个位置应显示的元素
        String[][] res = new String[arrayHeight][arrayWidth];
        // 对数组进行初始化，默认为一个空格
        for (int i = 0; i < arrayHeight; i ++) {
            for (int j = 0; j < arrayWidth; j ++) {
                res[i][j] = " ";
            }
        }

        // 从根节点开始，递归处理整个树
        // res[0][(arrayWidth + 1)/ 2] = (char)(root.val + '0');
        writeArray(root, 0, arrayWidth/ 2, res, treeDepth);

        // 此时，已经将所有需要显示的元素储存到了二维数组中，将其拼接并打印即可
        for (String[] line: res) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < line.length; i ++) {
                sb.append(line[i]);
                if (line[i].length() > 1 && i <= line.length - 1) {
                    i += line[i].length() > 4 ? 2: line[i].length() - 1;
                }
            }
            System.out.println(sb.toString());
        }
    }

接下来，是用于测试的程序，如果需要调用上面的方法，以下面的代码为demo即可。需要注意的一点是，其中构建树的代码为如何创建一棵树中的方法，需要将这些.java文件放在个包中（包括TreeNode.java），才可以正常使用。

public class P236_LowestCommonAncestorOfABinaryTree{
	 public static void main(String[] args) {

        String s = "[3,5,1,6,2,0,8,null,null,7,4]";
         TreeNode treeNode = TreeNode.strToTree(s);
         TreeNode.show(treeNode);

Solution();

	 }

输出：

            3            
         /     \         
      5           1      
    /   \       /   \    
  6       2   0       8  
         / \             
        7   4            

进程已结束,退出代码0

可以看到，之后我们只用两行代码，便创建出了一棵我们需要的树，并且按照树的格式将一棵完整的树打印了出来。无论是创建还是打印出来分析调试，都是非常棒的工具。

4 不足之处

由于本方法的思路是基于字符串的数组的，所以并不可能完美适配所有情况，比如当树的高度很高以后，可能看起来会很奇怪。

还有一个问题就是，虽然已经做了自适应处理，但是，如果出现超过5位的数字（比如123123），其所在的行可能会有一点向右的偏移，若偏的不多，是不影响观察的，但若偏的多了就。。。。不过这里已经做了处理，所以出现三位或者四位数的时候是没有问题的。

不过，在日常的应用中，应该是完全够用的，希望这段代码能为大家带来便利。

5 完整代码

TreeNode的工具类：

直接将下面的代码引入自己的项目，调用就可以快速创建一个TreeNode和观察一个TreeNode的结构

package cn.wanghaixin.solution.utils;


import com.alibaba.fastjson.JSON;

import java.util.ArrayList;
import java.util.List;

/**
 * @program: health_band_webserver
 * @description: 操作数组的工具类
 * @author: Wang Hai Xin
 * @create: 2022-11-01 18:04
 **/
public   class ArrayUtil {


/**
 * description: 打印list
 * @author Wang Hai Xin
 * @date 2023/3/17 13:49
 * 
 * @param data
 * @return java.lang.String
 */
    public static String arrayListToString(List data) {

        String s = JSON.toJSON(data).toString();

        return s;
    }

    public static String arrayToString(int[] data) {
        int len = data.length;
        StringBuilder res = new StringBuilder();
        res.append("[");
        for (int i = 0; i < len; i++) {
            if (i == len-1) {
                res.append(data[i]);
            }else{
                res.append(data[i]+",");
            }
        }
        res.append("]");

        return res.toString();
    }

/**
 * description: StrToCharacterArray
 * 二维数组字符串转化为二维Character数组
 * [["1","1","1","1","0"],["1","1","0","1","0"],["1","1","0","0","0"],["0","0","0","0","0"]]
 * @author Wang Hai Xin
 * @date 2023/3/14 15:26
 * 
 * @param str
 * @return java.lang.Character[][]
 */
    public static Character[][] StrToCharacterArray(String str) {

        //字符串转换成二维数组
        Character[][] characters = JSON.parseObject(str, Character[][].class);

        return characters;
    }


    /**
     * description: IntegerToStrArray
     * Integer[][] toStr= new Integer[][]{{1,2,3},{4,5,6}};
     *二维integer数组转化为字符串
     * @param array
     * @return java.lang.String
     * @author Wang Hai Xin
     * @date 2023/3/14 15:24
     */

    public static String IntegerToStrArray(Integer[][] array) {

        String s = JSON.toJSON(array).toString();
        return s;
    }

    /**
     * description: StrToIntArrayAll
     * <p>二维Integer数组字符串转化为Integer数组
     * String s = "[[22,23,23],[1,10,20]]";
     *
     * @param str
     * @return java.lang.Integer[][]
     * @author Wang Hai Xin
     * @date 2023/3/14 15:22
     */
    public static Integer[][] StrToIntegerArray(String str) {

        //字符串转换成二维数组
        Integer[][] parse = JSON.parseObject(str, Integer[][].class);

        return parse;
    }

    /**
     * description: StrToArrayList 数组字符串转list
     * @author Wang Hai Xin
     * @date 2023/3/22 17:01
     * 
     * @param str [1,null,2,3]
     * @return java.util.List<java.lang.Integer>
     */
    public static List<Integer> StrToArrayList(String str) {

        str = str.substring(1, str.length() - 1).trim();

        String[] strs = str.split(",");


        List<Integer> arr = new ArrayList(strs.length);
        if (str.equals("")) {
            return null;
        }

        for (int i = 0; i < strs.length; i++) {

            if (strs[i].equals("null")) {

                arr.add(null);
            } else {
                arr.add(Integer.parseInt(strs[i]));
            }

        }

        return arr;

    }

    /**
     * description: StrToIntArray 将数组字符串转化为数组
     * int []arr = {3, 9, 20, Integer.MAX_VALUE, Integer.MAX_VALUE, 15, 7};
     * 将字符数组转化为数字数组
     * @author Wang Hai Xin
     * @date 2023/3/16 14:35
     *
     * @param str
     * @return int[]
     */

    public static int[] StrToIntArray(String str) {

        str = str.substring(1, str.length() - 1).trim();

        String[] strs = str.split(",");


        int[] arr = new int[strs.length];
        if (str.equals("")) {
            return null;
        }

        for (int i = 0; i < arr.length; i++) {

            if (strs[i].equals("null")) {

                arr[i] = Integer.MAX_VALUE;

            } else {

                arr[i] = Integer.parseInt(strs[i]);

            }

        }

        return arr;

    }


    /**
     * description: arraysAvgFileZero  求数组平均值 排除零
     *
     * @param data
     * @return java.lang.Integer
     * @author Wang Hai Xin
     * @date 2023/1/12 18:30
     */

    public static Integer arraysAvgFileZero(Integer[] data) {
        int len = data.length;
        if (data == null && 0 == len) {
            return 0;
        }
        Integer sum = 0;
        Integer num = 0;
        for (int i = 0; i < len; i++) {
            if (data[i] != 0) {
                sum += data[i];
                num++;
            }
        }
        if (num != 0) {
            return sum / num;
        } else {
            return sum;
        }
    }

    /**
     * description: ArraysAvg 求数组平均值
     *
     * @param data
     * @return java.lang.Integer
     * @author Wang Hai Xin
     * @date 2022/11/1 18:12
     */

    public static Integer arraysAvg(Integer[] data) {
        int len = data.length;
        if (data == null && 0 == len) {
            return 0;
        }
        Integer sum = 0;
        for (int i = 0; i < len; i++) {
            sum += data[i];
        }
        return sum / len;
    }

    /**
     * description: stringToArray 将数字类型的字符数组转化为 int类型的数组
     *
     * @param data
     * @return java.lang.Integer[]
     * @author Wang Hai Xin
     * @date 2023/1/12 18:28
     */

    public static Integer[] stringToArray(String data) {
        data = data.substring(1, data.length() - 1).trim();

        String[] split = data.split(",");
        int len = split.length;
        Integer[] res = new Integer[len];
        for (int i = 0; i < len; i++) {

            if (split[i].equals("null")) {
                res[i] = null;

            } else {
                res[i] = Integer.parseInt(split[i].trim());

            }


        }
        return res;
    }


}

6 AC

我也通过工具类快速AC了这道题目：

解答成功:
	执行耗时:6 ms,击败了99.98% 的Java用户
	内存消耗:42.9 MB,击败了35.02% 的Java用户

关于算法题的题解 可以看我的算法系列文章，希望对大家有所帮助。
在这里插入图片描述

黑白极客
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
图形化生成树（二叉树 哈夫曼树 和 最小树）
12-08
没啥好说的 本来只想免费分享出去很早以前的课程设计 资源分最低最低只能选2，我就把二叉树 哈夫曼树 和 最小树放到一起了 作为参考啊
数据结构实验：判断一棵二叉树是否是二叉排序树
10-17
一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树...
打印一棵二叉树（详细版）
unbelieveme的博客
03-12 8146
打印一棵二叉树 二叉树：是一种重要的树状数据结构，通常由根节点，左子树和有子树构成，其中除叶子节点以外，每一个节点最少含有一个分支节点，最多含有两个分支节点。正是由于这种特殊的性质，使得二叉树在数据存储，数据排序以及顺序查找当中有重大的应用。 ①节点：包含一个数据元素及若干指向子树分支的信息 ②节点的度：一个节点拥有子树的数目称为节点的度 ③叶子节点：也称为终端节点，没有子树的节点或者度为零的节点 ④分支节点：也称为非终端节点，度不为零的节点称为非终端节点 ⑤树的度：树中所有节点的度的最大值 ⑥节点的层次
二叉树-7.1 二叉树序列打印
Iamlzm的博客
04-14 582
在前序遍历中，我们每遍历到一个结点，当即把它打印出来，然后把它的左孩子压入栈中，遇到空结点时，把退栈得到栈顶元素x，然后x的右子树按上面做法继续压入栈中。观察递归做法中的前序遍历，可以发现：我们每遍历一个结点，当即打印出该结点，然后以左孩子，右孩子的顺序接着往下递归。一种通用的迭代解法。按照这个顺序，1入栈，2入栈，2出栈并打印，3入栈，3出栈并打印，轮到1时，因为它还有右子树，所以要把3再次入栈，这样就会重复打印3了，所以要使用一个栈打印结点值，除了记录当前正在遍历的结点，还要记录之前已经访问过的结点。
【C语言】打印二叉树树形（制表符实现，清晰+高拓展）（2022-10-22 更新—偏移量说明）
Ice__Clean的博客
11-01 9741
—— 目录 ——0. 前言1. 效果展示2. 核心代码及解读3. 辅助代码 0. 前言 上 CSDN 找了很多份树形代码，一个共通的感觉就是拓展性不够强 比如说树大了节点之间被撑开无法兼容性不好 没有使用树枝连接的画显示稍显混乱，使用斜线当树枝又不好拓展 还有一部分就是代码太冗长看不懂 基于此，我打算用回制表符，力求清晰显示出树形 肝了几个小时的代码，过程中一点一点调出来树形 代码部分也在不断优化，思路在不断的调试中也不断改变 最后总结出一种以绝对偏移量画树形的方法，下边将一一对代码进行解释 1. 效果展
构建、打印二叉树JAVA
星回昭以烂的博客
08-23 661
构建、打印二叉树JAVA
python数据结构树和二叉树简介
01-20
树形结构是一类重要的非线性结构。树形结构是结点之间有分支，并具有层次关系的结构。它非常类似于自然界中的树。树的递归定义：树(Tree)是n(n≥0)个结点的有限集T，T为空时称为空树，否则它满足如下两个条件：(1)有...
数据结构作业：唯一确定一棵二叉树.doc
01-06
数据结构作业：唯一确定一棵二叉树.doc
树形结构的3中搜索方式示例分享
01-21
代码如下:/**树的3中常见搜索方式1.二叉树方式（每一层只有0和1）2.满m叉树（每一层都有0 到m – 1）3.子集树，也称为全排列树*/#include <iostream>#include <cstdio>#include <algorithm>#include <cstring>#...
二叉树一种树形结构概念及特点
最新发布
10-30
二叉树一种树形结构概念及特点
构建一颗二叉树，并将其打印出来（c++实现）
qq_37795916的博客
03-26 1590
求树的深度打印树感觉太繁琐了，直接拿去用就行，不需要知道细节。
打印二叉树 - java实现
JokerBee的博客
07-04 407
二叉树打印
数据结构--建立与输出二叉树
m0_62476845的博客
04-01 4838
建立与输出二叉树--C语言实现太多了不会？跟着我的代码敲，熟能生巧，一个一个模块去做，分治法大事化小。看着代码自己打一遍，能运行就是成功。
【数据结构与算法】【14】以树状形式打印二叉树
命运之手
06-14 3611
技术难点以树状形式打印二叉树的关键难点在于，如何计算和控制每个节点的打印位置解决思路将二叉树的所有节点从左往右全部打印出来，正好和二叉树中序遍历的结果是一样的利用这个特点，我们就可以通过中序遍历结果，来反推每个节点位置，再按广度优先遍历算法，逐行打印即可具体方案和流程图如下二叉树 中序遍历每个字符间要保持一定间隔，所以加上占位符 广度优先遍历保持每个节点横向位置不变，根据广度优先遍历调整节点层次位置 将占位符替换为连接符和空白字符 这样就大功告成了，思路有了，实现就不难了注意细节实现代码这里我们只讲解怎么打
【数据结构实验】简单打印二叉树超详细讲解（含二叉树每一个元素所在层数的算法和求二叉树深度的代码）
亿维数组's博客
05-22 2372
问题描述 打印二叉树结构（设计性实验） 问题描述 按凹入表形式横向打印二叉树结构，即二叉树的根在屏幕的最左边，二叉树的左子树在屏幕的下 边，二叉树的右子树在屏幕的上边。例如： 测试数据 由读者依据软件工程的测试技术自己确定。注意测试边界数据，如空二叉树。 实验分析 首先观察例子中打印的二叉树的排版格式，如果把图片顺时针旋转90度，就能看到非常直观的二叉树的排版，现在需要从中找到规律，从而用代码将其实现。 经过观察发现： 打印出的二叉树中，每一行可以看成只有一个元素，最.
java生成并打印二叉树
weixin_53341608的博客
09-14 215
【代码】java生成并打印二叉树。
使用python打印一棵二叉树
unbelieveme的博客
02-06 3572
使用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
从上到下打印二叉树
Bzdjsmz的博客
07-27 187
建立一个vector数组ret用来当做返回的结果数组，建立一个队列用来接收二叉树的内容，当队列不为空时，取出队列的队头元素temp，将其val数值压入结果数组中，然后再将该队列队头元素弹出，最后依次访问temp的左右子树，若不为空，压入队列中，进行下一步的判断和结果数组的压入。从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。给定二叉树: [3,9,20,null,null,15,7],
二叉树的树状打印（Java）
Myd
07-27 3984
树型结构的打印难点是如何处理好同一行不同节点之间的位置关系，空格和连接线的位置长度；只要弄清楚这些就可以写代码了。
java 中 数据 树形结构
05-23
Java中常用的树形结构有以下几种： 1.二叉树（Binary Tree）：每个节点最多拥有两个子节点的树形结构。 2.二叉搜索树（Binary Search Tree）：是一种特殊的二叉树，它的左子树上所有节点的值都小于根节点的值，右...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

黑白极客

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值