二叉树的递归遍历(java实现)

最新推荐文章于 2023-04-20 05:50:26 发布
最新推荐文章于 2023-04-20 05:50:26 发布
阅读量242 收藏
点赞数
分类专栏： 数据结构 java 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18402949/article/details/102754445
版权

二叉树的递归遍历(java实现)

二叉树是数据结构中非常重要的一章，而二叉树的遍历是重中之重。本文记载了我构造二叉树并对一棵简单的二叉树进行前、中、后序遍历的经验，因为本人是新手，不足之处还请谅解，欢迎指正。

创建树类

package tree;

public class BinaryTree {
    TreeNode root;
    public BinaryTree(){
        System.out.println("创建一棵树完成");
    }
    //设置根节点
    public void setRoot(TreeNode root) {
        this.root = root;
        System.out.println("在树中成功创建了一个根节点");
    }
 }

创建节点类

package tree;

public class TreeNode {
    //节点中具有value值，此处声明
    int value;
    //值的两端是左右节点的引用
    TreeNode leftNode;
    TreeNode rightNode;
    //构造器，在声明一个节点时传值。
    public TreeNode(int value){
        this.value=value;
    }
    //创建一个节点的左节点
    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
        System.out.println("创建左节点完成");
    }
    //创建一个节点的右节点
    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
        System.out.println("创建右节点完成");
    }
}

前序遍历

前序遍历首先遍历根节点，之后遍历左子树，最后遍历右子树。在遍历左右子树时，同样是按照前序遍历原则进行遍历。
以下是递归实现：

package tree;

public class BinaryTree {
    TreeNode root;
    public BinaryTree(){
        System.out.println("创建一棵树完成");
    }
    //设置根节点
    public void setRoot(TreeNode root) {
        this.root = root;
        System.out.println("在树中成功创建了一个根节点");
    }
    //前序遍历
    public void frontShow(){
        System.out.println("前序遍历的结果是： ");
        root.frontShow();
        System.out.println();
    }
}


package tree;

public class TreeNode {
    //节点中具有value值，此处声明
    int value;
    //值的两端是左右节点的引用
    TreeNode leftNode;
    TreeNode rightNode;
    //构造器，在声明一个节点时传值。
    public TreeNode(int value){
        this.value=value;
    }
    //创建一个节点的左右节点
    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
        System.out.println("创建左节点完成");
    }
    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
        System.out.println("创建右节点完成");
    }
    //前序遍历
    public void frontShow(){
        System.out.print(value);
        if(leftNode!=null){
            leftNode.frontShow();
        }
        if(rightNode!=null){
            rightNode.frontShow();
        }
    }
}


package tree;

public class TestBinaryNode{
    public static void main(String[] args) {
        //创建一棵树
        BinaryTree binaryTree=new BinaryTree();
        //创建一个根节点
        TreeNode root=new TreeNode(1);
        //创建左节点
        TreeNode leftNode=new TreeNode(2);
        //创建右节点
        TreeNode rightNode=new TreeNode(3);
        //将root赋值给binaryTree的根节点
        binaryTree.setRoot(root);
        //给根节点root创建左右节点
        root.setLeftNode(leftNode);
        root.setRightNode(rightNode);
        //继续给binaryTree树创建增加节点
        leftNode.setLeftNode(new TreeNode(4));
        leftNode.setRightNode(new TreeNode(5));
        rightNode.setLeftNode(new TreeNode(6));
        rightNode.setRightNode(new TreeNode(7));

        //调用树的前序遍历方法
        binaryTree.frontShow();
    }
}

中序遍历

中序遍历首先遍历根节点的左子树，再遍历根节点，最后遍历右子树。在遍历左右子树时，同样是按照中序遍历原则进行遍历。
以下是递归实现：

package tree;

public class BinaryTree {
    TreeNode root;
    public BinaryTree(){
        System.out.println("创建一棵树完成");
    }
    //设置根节点
    public void setRoot(TreeNode root) {
        this.root = root;
        System.out.println("在树中成功创建了一个根节点");
    }
    //中序遍历
    public void midShow(){
        System.out.println("中序遍历的结果是： ");
        root.midShow();
        System.out.println();
    }
}


package tree;

public class TreeNode {
    //节点中具有value值，此处声明
    int value;
    //值的两端是左右节点的引用
    TreeNode leftNode;
    TreeNode rightNode;
    //构造器，在声明一个节点时传值。
    public TreeNode(int value){
        this.value=value;
    }
    //创建一个节点的左右节点
    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
        System.out.println("创建左节点完成");
    }
    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
        System.out.println("创建右节点完成");
    }
    //中序遍历
    public void midShow(){
        if(leftNode!=null){
            leftNode.midShow();
        }
        System.out.print(value);
        if(rightNode!=null){
            rightNode.midShow();
        }

    }
}


package tree;

public class TestBinaryNode{
    public static void main(String[] args) {
        //创建一棵树
        BinaryTree binaryTree=new BinaryTree();
        //创建一个根节点
        TreeNode root=new TreeNode(1);
        //创建左节点
        TreeNode leftNode=new TreeNode(2);
        //创建右节点
        TreeNode rightNode=new TreeNode(3);
        //将root赋值给binaryTree的根节点
        binaryTree.setRoot(root);
        //给根节点root创建左右节点
        root.setLeftNode(leftNode);
        root.setRightNode(rightNode);
        //继续给binaryTree树创建增加节点
        leftNode.setLeftNode(new TreeNode(4));
        leftNode.setRightNode(new TreeNode(5));
        rightNode.setLeftNode(new TreeNode(6));
        rightNode.setRightNode(new TreeNode(7));

        //调用树的前序遍历方法
        binaryTree.midShow();
    }
}

后序遍历

后序遍历首先遍历根节点的左子树，再遍历右子树，最后遍历根节点。在遍历左右子树时，同样根据后序遍历的规则来进行遍历。
以下是递归实现：

```java
package tree;

public class BinaryTree {
    TreeNode root;
    public BinaryTree(){
        System.out.println("创建一棵树完成");
    }
    //设置根节点
    public void setRoot(TreeNode root) {
        this.root = root;
        System.out.println("在树中成功创建了一个根节点");
    }
    //后序遍历
    public void afterShow(){
        System.out.println("后序遍历的结果是： ");
        root.afterShow();
        System.out.println();
    }
}


package tree;

public class TreeNode {
    //节点中具有value值，此处声明
    int value;
    //值的两端是左右节点的引用
    TreeNode leftNode;
    TreeNode rightNode;
    //构造器，在声明一个节点时传值。
    public TreeNode(int value){
        this.value=value;
    }
    //创建一个节点的左右节点
    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
        System.out.println("创建左节点完成");
    }
    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
        System.out.println("创建右节点完成");
    }
   //后序遍历
    public void afterShow(){
        if (leftNode!=null){
            leftNode.afterShow();
        }
        if (rightNode!=null){
            rightNode.afterShow();
        }
        System.out.print(value);
    }
}


package tree;

public class TestBinaryNode{
    public static void main(String[] args) {
        //创建一棵树
        BinaryTree binaryTree=new BinaryTree();
        //创建一个根节点
        TreeNode root=new TreeNode(1);
        //创建左节点
        TreeNode leftNode=new TreeNode(2);
        //创建右节点
        TreeNode rightNode=new TreeNode(3);
        //将root赋值给binaryTree的根节点
        binaryTree.setRoot(root);
        //给根节点root创建左右节点
        root.setLeftNode(leftNode);
        root.setRightNode(rightNode);
        //继续给binaryTree树创建增加节点
        leftNode.setLeftNode(new TreeNode(4));
        leftNode.setRightNode(new TreeNode(5));
        rightNode.setLeftNode(new TreeNode(6));
        rightNode.setRightNode(new TreeNode(7));

        //调用树的前序遍历方法
        binaryTree.afterShow();
    }
}

以下是我将前序、中序、后序遍历代码整合之后的运行图：

在这里插入图片描述

LC今天刷LC了吗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java二叉树的遍历思想及核心代码实现
08-26
Java二叉树的遍历思想及核心代码实现 Java二叉树的遍历思想及核心代码实现是计算机科学中的一种重要概念，它是指对二叉树进行遍历的思想和实现方法。二叉树是一种特殊的树形结构，它的每个结点最多有两个孩子结点，...
[力扣]144. 二叉树的前序遍历java
12-21
2.递归遍历左子树，把左子树的遍历结果加入到List中； 3.递归遍历右子树，把右子树的遍历结果加入到List中。 4.返回 代码 /** * Definition for a binary tree node. * public class TreeNode { * int val; * ...
Day14--数据结构与算法(Java)二叉树的递归遍历和迭代遍历
qq_52698263的博客
12-15 307
二叉树的前序遍历，中序遍历，后序遍历，分别用递归法和迭代法来实现。
Java实现二叉树的遍历
朝花夕拾
04-07 4723
6.8 遍历二叉树 假设，我手头有20张100元的和2000张1元的奖券，同时洒向了空中，大家比赛看谁最终捡的最多。如果是你，你会怎么做? 相信所有同学都会说， 一定先捡100元的。道理非常简单，因为捡一张100元等于1元的捡100张，效率好得不是一点点。所以可以得到这样的结论，同样是捡奖券，在有限时间内，要达到最高效率，次序非常重要。对于二叉树的遍历来讲，次序同样显得很重要。 二叉
【Java 数据结构】二叉树的遍历 (递归和非递归实现)
热门推荐
书生-w的博客
04-20 1万+
递归的执行时的函数栈帧就是递出去再回退, 如果要模拟递归, 一般情况下都是使用栈, 前序遍历(根, 左, 右)二叉树的非递归实现就是, 没有递归就只能用利用while循环 按照前线遍历的思路，在循环里头先添加根结点，然后不断往左遍历，直到左树为空，再继续遍历右树。从添加左树转为右树时，有个难点，右树可能为空，也可能不为空，如果右树为空,循环就直接结束了,我们没办法遍历剩下的元素了,所以我们需要要在外层再套上一个循环,当栈不为空时,从栈里面弹出一个元素继续遍历.
Java创建遍历二叉树（递归）并求树高及叶节点个数（代码全）
m0_55975991的博客
12-16 3639
二叉树的前序、中序、后序及层序全遍历方式，及递归求解树高（深度）和而叶子结点的个数全代码
java实现二叉树的遍历（递归，前序、中序以及后序）
qq_44665283的博客
08-30 590
1、二叉树的遍历 二叉树分为的遍历有三种，分别为前序、中序和后序遍历。 前序遍历是指：先输出父节点，然后是左子树，右子树； 中序遍历是指：先遍历左子树，然后父节点，然后右子树； 后序遍历是指：先遍历左子树，然后右子树，最后是父节点。 1、先定义节点 /** * 创建一个节点 */ @AllArgsConstructor @NoArgsConstructor @Data class Node{ private int num; private Node left;//左子节点，默认为nul
Java实现先序遍历二叉树
最新发布
04-26
在Java中，实现二叉树的先序遍历可以通过递归来完成。先序遍历的顺序是：首先访问根节点，然后递归地先序遍历左子树，最后递归地先序遍历右子树。 在这段代码中，Node类定义了二叉树的节点，包含数据域和指向左右子...
二叉树递归中序遍历java
12-09
java编程，二叉树的中序遍历，递归实现
Java~二叉树的前中后序遍历的几种方式（递归法，迭代法，标记法等）
Zebra的博客
01-09 1648
一.结点的定义 首先这里先给出结点的定义，和leetcode树相关的题目都是这么定义结点的 class TreeNode { int val; TreeNode left; TreeNode right; TreeNode() {} TreeNode(int val) { this.val = val; } TreeNode(int val, TreeNode left, TreeNode right) { th
二叉树非递归遍历Java实现
zfyseu1的专栏
06-30 2039
二叉树的前序、中序和后序遍历可以采用递归和非递归的方法实现，递归的方法逻辑简单清晰，易于理解，但递归的方法需要使用额外的栈空间，运行效率较低。而非递归的方法则效率较高。 维基百科上有递归和非递归二叉树三种遍历实现的伪代码，https://en.wikipedia.org/wiki/Tree_traversal#In-order_2 下面是相应的Java实现： 前序遍历（非递归
【数据结构】二叉树（遍历方法、递归实现）的JAVA代码实现
Yngz_Miao的博客
03-31 1万+
二叉树的遍历 二叉树的遍历是指按照某种顺序访问二叉树中的每个结点，使每个结点被访问一次且仅被访问一次。通过一次完整的遍历，可使二叉树中的结点信息由非线性排列变成某种意义上的线性序列。也就是说，遍历操作是非线性结构线性化。 由二叉树的定义可知，一棵二叉树由根结点、左子树和右子树三部分组成。因此，只需要依次遍历这三个部分，就可以遍历整个二叉树。若以D、L、R分别表示访问根结点、遍历根结点的左子树和...
java 递归二叉树遍历二叉树,Java通过递归进行二叉树遍历，java递归二叉树遍,package com....
weixin_33489161的博客
03-14 85
Java通过递归进行二叉树遍历，java递归二叉树遍,package com.package com.wzs;// 测试二叉树遍历,递归算法public class TestBinaryTree { public static void main(String[] args) { Node g = new Node("G", null, null); Node e...
java二叉树递归算法_Java二叉树的四种遍历(递归和非递归)
weixin_35375774的博客
02-20 395
二叉树的遍历可以分为前序、中序、后序、层次遍历。前中后是指何时访问中间节点，即前序遍历，遍历节点的顺序为：中—>左—>右；中序遍历，遍历节点的顺序为：左—>中—>右；后序遍历，遍历节点的顺序为：左—>右—>中。前序遍历递归实现public void preorder_Traversal(TreeNode root){if(root==null)return;//...
【数据结构】-java实现- 完全二叉树的创建以及递归遍历算法实现
小呼哥的博客
08-12 1327
文章中主要用java实现完全二叉树的创建以及二叉树的递归遍历算法。 重点在于完全二叉树的创建，递归算法比较容易些。 二叉树的创建 创建之前首先要了解完全二叉树的一些性质。 性质：如果有一颗有n个节点的完全二叉树的节点按层次序编号，对任一层的节点i（0<=i<=n）有（注意i的取值） 1.如果i=0，则节点是二叉树的根，无双亲，如果i>0，则其双亲节点为[i/2]，向下取整 2.如...
java递归遍历二叉树_Java通过递归进行二叉树遍历详解
weixin_32427105的博客
02-17 124
// 测试二叉树遍历,递归算法public class TestBinaryTree {public static void main(String[] args) {Node g = new Node("G", null, null);Node e = new Node("E", null, null);Node f = new Node("F", null, null);Node d = ne...
Java二叉树的遍历详解（递归）
qq_44859843的博客
09-22 246
```java package com.yang.traverse; /** * 二叉树的递归遍历（先序、中序、后序） */ public class BinaryTree { // 内部类，定义树的结点 public static class TreeNode{ // 数据域 String data; // 左孩子树 TreeNode left; // 右孩子树 TreeNode rig.
java 二叉树遍历_图解二叉树的三种遍历方式及java实现代码
weixin_39624716的博客
02-12 177
二叉树(binary tree)是一颗树，其中每个节点都不能有多于两个的儿子。1.二叉树节点作为图的特殊形式，二叉树的基本组成单元是节点与边；作为数据结构，其基本的组成实体是二叉树节点(binary tree node)，而边则对应于节点之间的相互引用。如下，给出了二叉树节点的数据结构图示和相关代码：// 定义节点类：private static class BinNode {private Ob...
二叉树的递归遍历java
09-26
在Java中，可以使用以下代码来实现二叉树的递归遍历： ```java public class BinaryTree { // 其他代码... // 先序遍历 public void preOrderRecursive(BinaryTreeNode root) { if (root != null) { System....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值