JAVA二叉树的遍历和序列化

最新推荐文章于 2021-11-18 00:25:58 发布
最新推荐文章于 2021-11-18 00:25:58 发布
阅读量420 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35055467/article/details/69808462
版权
二叉树实体类
public class TreeNode {
    private int val = 0;
    private TreeNode left = null;
    private TreeNode right = null;

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

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    public TreeNode getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }
}

递归遍历

    /**
     * 前序遍历(根左右)
     */
    public void DLR(TreeNode head) {
        if (head == null) return;
        System.out.print(head.getVal());
        if (head.getLeft() != null) DLR(head.getLeft());
        if (head.getRight() != null) DLR(head.getRight());
    }

    /**
     * 中序遍历(左根右)
     */
    public void LDR(TreeNode head) {
        if (head == null) return;
        if (head.getLeft() != null) LDR(head.getLeft());
        System.out.print(head.getVal());
        if (head.getRight() != null) LDR(head.getRight());
    }

    /**
     * 后序遍历(左右根)
     */
    public void LRD(TreeNode head) {
        if (head == null) return;
        if (head.getLeft() != null) LRD(head.getLeft());
        if (head.getRight() != null) LRD(head.getRight());
        System.out.print(head.getVal());
    }

递归遍历没什么好说的，比较简单，下面介绍非递归遍历

非递归遍历

    /**
     * 前序遍历（非递归）
     */
    public void dlr_by_stack(TreeNode head) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(head);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            System.out.print(node.getVal());
            if (node.getRight() != null) {
                stack.push(node.getRight());
            }
            if (node.getLeft() != null) {
                stack.push(node.getLeft());
            }
        }
    }

1：准备一个栈，头节点先入栈。
2：弹出栈顶节点，打印节点的值，然后当前结点的右孩子和左孩子依次入栈
3：重复步骤2直到栈为空
由于栈的结构是先进后出，所以每次先弹出的都是左孩子。弹出左孩子后又将该节点的右孩子和左孩子依次入栈。这样就实现了根左右的遍历顺序。

    /**
     * 中序遍历(非递归)
     */
    public void ldr_by_stack(TreeNode head) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode cur = head;
        while (!stack.isEmpty() || cur != null) {
            if (cur != null) {
                stack.push(cur);//左孩子依次入栈
                cur = cur.getLeft();
            } else {//左孩子为空时，打印节点值
                cur = stack.pop();
                System.out.print(cur.getVal());
                cur = cur.getRight();
            }
        }
    }

1：同样先准备一个栈，令头节点先入栈
2：将整颗树的左孩子依次入栈，当没有左孩子时，右孩子入栈
3：重复步骤2直到栈为空或者当前结点为空

    /**
     * 后序遍历(非递归)
     */
    public void lrd_by_stack(TreeNode head) {
        Stack<TreeNode> s1 = new Stack<>();
        Stack<TreeNode> s2 = new Stack<>();
        s1.push(head);
        while (!s1.isEmpty()) {
            TreeNode node = s1.pop();
            s2.push(node);
            if (node.getLeft() != null) s1.push(node.getLeft());
            if (node.getRight() != null) s1.push(node.getRight());
        }

        while (!s2.isEmpty()) {
            System.out.print(s2.pop().getVal());
        }
    }

1:准备两个栈s1和s2，头节点进入s1
2：弹出s1的栈顶节点，计为node，node入栈s2，node的左右节点依次入s1
3：重复步骤2直到s2为空，这是s2的出栈顺序就是后序遍历的结果

层序遍历

    /**
     * 层序遍历
     */
    public void printTree(TreeNode head) {
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        TreeNode node;
        TreeNode last = head;
        TreeNode nlast = last;
        queue.offer(head);

        while (!queue.isEmpty()) {
            node = queue.poll();
            System.out.print(node.getVal());
            if (node.getLeft() != null) {
                queue.offer(node.getLeft());
                nlast = node.getLeft();
            }
            if (node.getRight() != null) {
                queue.offer(node.getRight());
                nlast = node.getRight();
            }
            if (node == last) {
                last = nlast;
                System.out.println();
            }
        }
    }

序列化

将一颗二叉树序列化成字符串，空节点用#！表示

    /**
     * 前序序列化
     */
    private void serialize_dlr(TreeNode head, StringBuilder builder) {
        builder.append(head.getVal());
        builder.append("!");
        if (head.getLeft() != null) {
            serialize_dlr(head.getLeft(), builder);
        } else {
            builder.append("#!");
        }
        if (head.getRight() != null) {
            serialize_dlr(head.getRight(), builder);
        } else {
            builder.append("#!");
        }
    }
    /**
     * 中序序列化
     */
    private void serialize_ldr(TreeNode head, StringBuilder builder) {
        if (head.getLeft() != null) {
            serialize_ldr(head.getLeft(), builder);
        } else {
            builder.append("#!");
        }
        builder.append(head.getVal());
        builder.append("!");
        if (head.getRight() != null) {
            serialize_ldr(head.getRight(), builder);
        } else {
            builder.append("#!");
        }
    }
    /**
     * 后序序列化
     */
    private void serialize_lrd(TreeNode head, StringBuilder builder) {
        if (head.getLeft() != null) {
            serialize_lrd(head.getLeft(), builder);
        } else {
            builder.append("#!");
        }
        if (head.getRight() != null) {
            serialize_lrd(head.getRight(), builder);
        } else {
            builder.append("#!");
        }
        builder.append(head.getVal());
        builder.append("!");
    }

完整代码

/**
 * Created by Clanner on 2017/10/25.
 * 二叉树工具类
 */
public class TreeUtil {

    public static final int DLR = 1;
    public static final int LDR = 2;
    public static final int LRD = 3;

    private TreeUtil() {
    }

    public static final TreeUtil getInstance() {
        return Holder.instance;
    }

    private static final class Holder {
        private static final TreeUtil instance = new TreeUtil();
    }

    /**
     * 层序遍历
     */
    public void printTree(TreeNode head) {
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        TreeNode node;
        TreeNode last = head;
        TreeNode nlast = last;
        queue.offer(head);

        while (!queue.isEmpty()) {
            node = queue.poll();
            System.out.print(node.getVal());
            if (node.getLeft() != null) {
                queue.offer(node.getLeft());
                nlast = node.getLeft();
            }
            if (node.getRight() != null) {
                queue.offer(node.getRight());
                nlast = node.getRight();
            }
            if (node == last) {
                last = nlast;
                System.out.println();
            }
        }
    }

    /**
     * 前序反序列化
     *
     * @param head
     * @param values
     * @param index
     */
    private void deserialize_dlr(TreeNode head, String[] values, int index) {

    }

    /**
     * 前序序列化
     */
    private void serialize_dlr(TreeNode head, StringBuilder builder) {
        builder.append(head.getVal());
        builder.append("!");
        if (head.getLeft() != null) {
            serialize_dlr(head.getLeft(), builder);
        } else {
            builder.append("#!");
        }
        if (head.getRight() != null) {
            serialize_dlr(head.getRight(), builder);
        } else {
            builder.append("#!");
        }
    }

    /**
     * 中序序列化
     */
    private void serialize_ldr(TreeNode head, StringBuilder builder) {
        if (head.getLeft() != null) {
            serialize_ldr(head.getLeft(), builder);
        } else {
            builder.append("#!");
        }
        builder.append(head.getVal());
        builder.append("!");
        if (head.getRight() != null) {
            serialize_ldr(head.getRight(), builder);
        } else {
            builder.append("#!");
        }
    }

    /**
     * 后序序列化
     */
    private void serialize_lrd(TreeNode head, StringBuilder builder) {
        if (head.getLeft() != null) {
            serialize_lrd(head.getLeft(), builder);
        } else {
            builder.append("#!");
        }
        if (head.getRight() != null) {
            serialize_lrd(head.getRight(), builder);
        } else {
            builder.append("#!");
        }
        builder.append(head.getVal());
        builder.append("!");
    }

    /**
     * 前序遍历(根左右)
     */
    public void DLR(TreeNode head) {
        if (head == null) return;
        System.out.print(head.getVal());
        if (head.getLeft() != null) DLR(head.getLeft());
        if (head.getRight() != null) DLR(head.getRight());
    }

    /**
     * 前序遍历（非递归）
     */
    public void dlr_by_stack(TreeNode head) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(head);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            System.out.print(node.getVal());
            if (node.getRight() != null) {
                stack.push(node.getRight());
            }
            if (node.getLeft() != null) {
                stack.push(node.getLeft());
            }
        }
    }

    /**
     * 中序遍历(左根右)
     */
    public void LDR(TreeNode head) {
        if (head == null) return;
        if (head.getLeft() != null) LDR(head.getLeft());
        System.out.print(head.getVal());
        if (head.getRight() != null) LDR(head.getRight());
    }

    /**
     * 中序遍历(非递归)
     */
    public void ldr_by_stack(TreeNode head) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode cur = head;
        while (!stack.isEmpty() || cur != null) {
            if (cur != null) {
                stack.push(cur);//左孩子依次入栈
                cur = cur.getLeft();
            } else {//左孩子为空时，打印节点值
                cur = stack.pop();
                System.out.print(cur.getVal());
                cur = cur.getRight();
            }
        }
    }


    /**
     * 后序遍历(左右根)
     */
    public void LRD(TreeNode head) {
        if (head == null) return;
        if (head.getLeft() != null) LRD(head.getLeft());
        if (head.getRight() != null) LRD(head.getRight());
        System.out.print(head.getVal());
    }

    /**
     * 后序遍历(非递归)
     */
    public void lrd_by_stack(TreeNode head) {
        Stack<TreeNode> s1 = new Stack<>();
        Stack<TreeNode> s2 = new Stack<>();
        s1.push(head);
        while (!s1.isEmpty()) {
            TreeNode node = s1.pop();
            s2.push(node);
            if (node.getLeft() != null) s1.push(node.getLeft());
            if (node.getRight() != null) s1.push(node.getRight());
        }

        while (!s2.isEmpty()) {
            System.out.print(s2.pop().getVal());
        }
    }

    /**
     * 判断两个树是否相同
     */
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q == null) return true;
        if (p == null || q == null) return false;
        if (p.getVal() != q.getVal()) return false;
        return isSameTree(p.getLeft(), q.getLeft()) && isSameTree(p.getRight(), q.getRight());
    }


    /**
     * 序列化
     *
     * @param head 树的根节点
     * @param type 序列化方式
     */
    public String serialize(TreeNode head, int type) {
        StringBuilder builder = new StringBuilder();
        builder.append("type_id:");
        builder.append(type);
        builder.append(":");
        switch (type) {
            case DLR:
                serialize_dlr(head, builder);
                return builder.toString();
            case LDR:
                serialize_ldr(head, builder);
                return builder.toString();
            case LRD:
                serialize_lrd(head, builder);
                return builder.toString();
            default:
                return "序列化类型错误";
        }
    }

    /**
     * 层序构造,构建完全二叉树
     *
     * @param values
     */
    public TreeNode createTree(int[] values) {
        TreeNode head = new TreeNode(values[0]);
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        TreeNode node;
        TreeNode last = head;
        TreeNode nlast = last;
        queue.offer(head);

        int i = 1;
        while (i + 1 < values.length) {
            node = queue.poll();
            if (node.getLeft() == null) {
                node.setLeft(new TreeNode(values[i++]));
                queue.offer(node.getLeft());
                nlast = node.getLeft();
            }
            if (node.getRight() == null) {
                node.setRight(new TreeNode(values[i++]));
                queue.offer(node.getRight());
                nlast = node.getRight();
            }
            if (node == last) {
                last = nlast;
            }
        }
        return head;
    }
}
Clanner_Z
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉树的序列化和反序列化-前序遍历 非递归
tfdev的博客
12-22 459
二叉树的序列化和反序列化-前序遍历 非递归版本
序列化二叉树java实现
qq_29606255的博客
10-12 355
请实现两个函数，分别用来序列化和反序列化二叉树 思路：遍历二叉树，并将其拼成字符串返回。/* public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; }}
剑指Offer-Java-序列化二叉树
咸鱼塘
10-01 580
题目 请实现两个函数，分别用来序列化和反序列化二叉树 代码 此题的核心点是如何表示二叉树，并且解释。 /* public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = ...
序列化二叉树（Java）
sinat_40968110的博客
04-08 466
序列化二叉树（Java） 题目：序列化二叉树（Java） 分析：请实现两个函数，分别用来序列化和反序列化二叉树. 思路： 根据前序遍历规则完成序列化与反序列化。 所谓序列化指的是遍历二叉树为字符串； 所谓反序列化指的是依据字符串重新构造成二叉树。 依据前序遍历序列来序列化二叉树，因为前序遍历序列是从根结点开始的。 当在遍历二叉树时碰到Null指针时，这些Null指针被序列化为一个特殊的字符“#...
二叉树的序列化和反序列化java借助队列实现
stay_hungry_stay_foolish
01-01 1118
以先序遍历方式完成二叉树的序列化 public String serialize(TreeNode root){ if(root==null){ return "#,"; } return root.val+","+serialize(root.left)+serialize(root.right); }反序列化p
剑指offer编程试题Java实现--61.序列化二叉树
JingLisen的博客
08-26 412
个人博客：小景哥哥 61.序列化二叉树 题目描述 请实现两个函数，分别用来序列化和反序列化二叉树 算法思想：根据前序遍历规则完成序列化与反序列化。所谓序列化指的是遍历二叉树为字符串；所谓反序列化指的是依据字符串重新构造成二叉树。依据前序遍历序列来序列化二叉树，因为前序遍历序列是从根结点开始的。当在遍历二叉树时碰到Null指针时，这些Null指针被序列化为一个特殊的字符“#”。另外，结点...
详解java实现遍历二叉树的三种情况
08-30
这三种方法在处理二叉树问题时有着广泛的应用，例如在查找、排序和序列化二叉树等方面。 1. **前序遍历**： 前序遍历的顺序是：先访问根节点，然后遍历左子树，最后遍历右子树。对于给定的代码片段，它实现了前序...
[力扣]144. 二叉树的前序遍历java
12-21
在计算机科学中，二叉树是一种...总之，二叉树的前序遍历是一个基础但重要的概念，适用于多种场景，例如数据结构的序列化、搜索和复制等。通过递归的方式，我们可以轻松地实现这一遍历策略，并用Java代码将其表达出来。
二叉树遍历问题先序遍历、中序遍历和后序遍历等等最新详情介绍.docx
07-24
- 在二叉树的序列化和反序列化过程中，层序遍历也常常被用到。 #### 三、实现方法 遍历二叉树可以采用递归或迭代的方式来实现。 **递归方式**：递归方式简单直观，但是可能会导致栈溢出，尤其是在树的高度非常大...
java-leetcode面试题解Stack之第331题验证二叉树的前序序列化-题解.zip
最新发布
05-05
在IT领域，尤其是在Java编程和...因此，熟练掌握包括二叉树遍历、序列化和栈在内的基础知识，对于准备Java相关的IT职位面试至关重要。通过LeetCode上的这类练习，开发者可以不断磨练自己的技能，提高解决问题的能力。
序列化二叉树 -- java
hello world
11-18 328
题目描述 请实现两个函数，分别用来序列化和反序列化二叉树。 BinaryTreeNode二叉树定义： public class BinaryTreeNode { int value; BinaryTreeNode left; BinaryTreeNode right; public BinaryTreeNode() { } public BinaryTreeNode(int value) { this.value = value;
[剑指Offer]序列化二叉树(Java)
聚沙成塔
06-09 627
题目 序列化二叉树 -- newcoder 剑指Offer 61 题目描述 请实现两个函数，分别用来序列化和反序列化二叉树. 思路 * 思路1： * 1、非递归，层次遍历的思想 * 2、null节点用#表示，节点之间逗号隔开 * * 思路2： * 根据前序遍历规则完成序列化与反序列化。 * 所谓序列化指的是遍历二叉树为字符串； * 所谓反序列化指的是依据字符串重新构造成二叉树...
序列化二叉树（Java实现）
zjkC050818的博客
06-12 1147
本题为剑指offer面试题62 牛客网测试地址：https://www.nowcoder.com/questionTerminal/cf7e25aa97c04cc1a68c8f040e71fb84 [编程题]序列化二叉树 热度指数：34295时间限制：1秒空间限制：32768K 算法知识视频讲解 请实现两个函数，分别用来序列化和反序列化二叉树 Java c
剑指Offer:序列化二叉树（java版）
Cannon的博客
07-15 237
题目描述 请实现两个函数，分别用来序列化和反序列化二叉树 分析 原理还是根据二叉树的遍历过程，用 ！ 来分隔每个节点的值（方便反序列化），如果是空节点，就使用 # 来替代。 如果不熟悉二叉树的遍历，请先看二叉树的遍历 按先序遍历的序列化 按层序遍历的序列化 写法1： import java.util.*; public class Solution { String Serialize...
61.序列化二叉树(java)
gaopan1999的博客
03-07 140
题目描述 请实现两个函数，分别用来序列化和反序列化二叉树 二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。 二叉树的反序列化是指：根据某种遍历顺序...
java二叉树的序列化_二叉树的序列化与反序列化（代码实现和思路）
weixin_29613859的博客
02-25 349
今天要给大家分享的是关于二叉树的序列化与反序列化问题。请实现两个函数，分别用来序列化和反序列化二叉树，包含了具体的代码实现和思路。二叉树的序列化：将一棵二叉树根据某一种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树能够长久保存。序列化能够基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过某种符号表示空节点(#)，以 !代表着一个结点值...
序列化/反序列化二叉树 （Java实现）
王小东大将军的博客
03-29 252
请实现两个函数，分别用来序列化和反序列化二叉树 二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。 二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。 例如，我们可以把一个只有根节点为1的二叉树序列化为"1,"，然后通过自己.
java二叉树的序列化_算法-序列化二叉树详解
weixin_29698317的博客
02-25 116
/*[序列化二叉树][题目]请实现两个函数，分别用来序列化和反序列化二叉树。[解析]代码实现能力，bugfree。二叉树的序列化和反序列化，实际上就是要以一种输入和输出统一的二叉树遍历方式进行中间参数的传递。常用的二叉树便利方式有：中序，前序，后序和层次遍历。其中前序遍历最符合人们的习惯，并且在反序列化过程中，如果字符是以序列的形式到来的，我们不需要知道整颗树的完整结构就可以进行树的构建。从这个...
二叉树的序列化与反序列化 --java记录
zkhong07的博客
10-21 257
序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。 请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。 看题目序列化后的字符串为层次遍历输出样式，...
二叉树遍历：Java实现与理论解析
"本资源主要探讨了二叉树的遍历方法，包括前序遍历、中序遍历和后序遍历，并对二叉树的基本概念进行了深入解释，如满二叉树、平衡二叉树、二叉查找树（BST）及其操作。" 在计算机科学中，二叉树是一种重要的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值