二叉树的创建及前中后序遍历，前中后序查找（JAVA递归实现）

已于 2022-12-18 13:11:40 修改
阅读量127 收藏 1
点赞数
文章标签： java 数据结构
于 2022-12-18 12:08:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caowenyue/article/details/128360589
版权

一、二叉树的创建：树是依据节点存在的，需要节点类。

class Node{
    private int no;
    private String name;
    private Node left;//指向左节点
    private Node right;//指向右节点
    public Node(int no,String name){
        this.no = no;
        this.name = name;
    }
    
    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}
class BinaryTree{
//二叉树，创建根结点即可。
    private Node root;
    public void setRoot(Node root){
        this.root = root;
    }
}

二、前中后序遍历

代码如下：注意所有代码在节点类中写，在二叉树类中调用方法。

  1. 前序遍历：访问顺序：先根节点，再左子树，最后右子树； 
    public void PreOrder(){
        //前序遍历
        //先打印当前节点
        System.out.println(this);
        //左边不为空，递归
        if (this.left != null){
            this.left.PreOrder();
        }
        //右边不为空，递归
        if (this.right != null){
            this.right.PreOrder();
        }
    }
  2. 中序遍历：访问顺序：先左子树，再根节点，最后右子树； 
    public void MidOrder(){
        if (this.left != null){
            this.left.MidOrder();
        }
        System.out.println(this);
        if (this.right != null){
            this.right.MidOrder();
        }
    }
  3. 后序遍历：访问顺序：先左子树，再根节点，最后右子树； 
     public void BackOrder(){
        if (this.left != null) {
            this.left.BackOrder();
        }
        if (this.right != null){
            this.right.BackOrder();
        }
        System.out.println(this);
    }

三，前中后序查找：

        1.前序查找：

public Node PreCheck(int no){
        //前序查找
        //判断当前结点是否等于要查找的值的no
        if (this.no == no){
            return this;
        }
        //创建临时变量存储
        Node res = null;
        if (this.left != null){
            //左节点不为空，递归查找，接收返回值
            res = this.left.PreCheck(no);
        }
        if (res != null){
            //有返回值则说明找到值，直接返回
            return res;
        }
        if (this.right != null){
            //右节点不为空，递归查找，接收返回值
            res = this.right.PreCheck(no);
        }
        if (res != null){
            //有返回值则说明找到值，直接返回
            return res;
        }
        //最后前面都不执行，返回默认的结果null
        return res;
    }

        2.中序查找：

public Node infixOrderSerach(int no){
        Node res = null;
        if (this.left != null){
            res = this.left.infixOrderSerach(no);
        }
        if (res != null){
            return res;
        }
        if (this.no == no){
            return this;
        }
        if (this.right != null){
            res = this.right.infixOrderSerach(no);
        }
        if (res != null){
            return res;
        }
        return res;
    }

        3.后序查找：

public Node postOrderSearch(int no){
        Node res = null;
        if (this.left != null){
            res = this.left.postOrderSearch(no);
        }
        if (res != null){
            return res;
        }
        
        if (this.right != null){
            res = this.right.postOrderSearch(no);
        }
        if (res != null){
            return res;
        }
        if (this.no == no){
            return this;
        }
        
        return res;
    }

总结

所有代码及测试：

public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        Node root =  new Node(1,"zhangsan");
        Node node2 =  new Node(3,"wangwu");
        Node node1 =  new Node(2,"lisi");
        Node node3 =  new Node(4,"sunliu");
        Node node4 =  new Node(5,"zhouqi");
        root.setRight(node2);
        root.setLeft(node1);
        node2.setRight(node3);
        node3.setRight(node4);

        System.out.println("前序遍历");
        binaryTree.setRoot(root);
        binaryTree.preOrder();
        System.out.println("中序遍历");
        binaryTree.midOrder();
        System.out.println("后序遍历");
        binaryTree.backOrder();
        System.out.println("=======================");

        System.out.println(binaryTree.preSearch(2));
        System.out.println(binaryTree.infixSearch(2));
        System.out.println(binaryTree.postSearch(2));
        
    }

}

class BinaryTree{
    private Node root;
    public void setRoot(Node root){
        this.root = root;
    }

    public void preOrder(){
        if (this.root != null){
            this.root.PreOrder();
        }else {
            System.out.println("二叉树为空，无法遍历");
            return;
        }

    }

    public Node preSearch(int no){
        Node node = null;
        if (this.root != null){
            node = this.root.PreCheck(no);
        }else {
            System.out.println("二叉树为空，无法遍历");
            return null;
        }
        return node;
    }

    public void midOrder(){
        if (this.root != null){
            this.root.MidOrder();
        }else {
            System.out.println("二叉树为空，无法遍历");
            return;
        }
    }
    
    public Node infixSearch(int no){
        Node node = null;
        if (this.root != null){
            node = this.root.infixOrderSerach(no);
        }else {
            System.out.println("二叉树为空，无法遍历");
            return null;
        }
        return node;
    }

    public void backOrder(){
        if (this.root != null){
            this.root.BackOrder();
        }else {
            System.out.println("二叉树为空，无法遍历");
            return;
        }
    }
    
    public Node postSearch(int no){
        Node node = null;
        if (this.root != null){
            node = this.root.postOrderSearch(no);
        }else {
            System.out.println("二叉树为空，无法遍历");
            return null;
        }
        return node;
    }


}

class Node{
    private int no;
    private String name;
    private Node left;//指向左节点
    private Node right;//指向右节点

    public void PreOrder(){
        //前序遍历
        //先打印当前节点
        System.out.println(this);
        //左边不为空，递归
        if (this.left != null){
            this.left.PreOrder();
        }
        //右边不为空，递归
        if (this.right != null){
            this.right.PreOrder();
        }
    }

    public Node PreCheck(int no){
        //前序查找
        //判断当前结点是否等于要查找的值的no
        if (this.no == no){
            return this;
        }
        //创建临时变量存储
        Node res = null;
        if (this.left != null){
            //左节点不为空，递归查找，接收返回值
            res = this.left.PreCheck(no);
        }
        if (res != null){
            //有返回值则说明找到值，直接返回
            return res;
        }
        if (this.right != null){
            //右节点不为空，递归查找，接收返回值
            res = this.right.PreCheck(no);
        }
        if (res != null){
            //有返回值则说明找到值，直接返回
            return res;
        }
        //最后前面都不执行，返回默认的结果null
        return res;
    }



    public void MidOrder(){
        if (this.left != null){
            this.left.MidOrder();
        }
        System.out.println(this);
        if (this.right != null){
            this.right.MidOrder();
        }
    }

    public Node infixOrderSerach(int no){
        Node res = null;
        if (this.left != null){
            res = this.left.infixOrderSerach(no);
        }
        if (res != null){
            return res;
        }
        if (this.no == no){
            return this;
        }
        if (this.right != null){
            res = this.left.infixOrderSerach(no);
        }
        if (res != null){
            return res;
        }
        return res;
    }


    public void BackOrder(){
        if (this.left != null) {
            this.left.BackOrder();
        }
        if (this.right != null){
            this.right.BackOrder();
        }
        System.out.println(this);
    }

    public Node postOrderSearch(int no){
        Node res = null;
        if (this.left != null){
            res = this.left.postOrderSearch(no);
        }
        if (res != null){
            return res;
        }

        if (this.right != null){
            res = this.right.postOrderSearch(no);
        }
        if (res != null){
            return res;
        }
        if (this.no == no){
            return this;
        }

        return res;
    }

    public Node(int no,String name){
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}

VerSpre
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二叉树的非递归后序遍历算法实例详解
01-19
前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。方法有很多，这里只举一种，先定义栈结点的数据结构 代码如下:typedef struct{...
Java 二叉树的中序遍历
weixin_53545457的博客
01-19 569
二叉树的中序遍历简单给定一个二叉树的根节点root，返回它的中序遍历。示例 1：输入：输出：[1,3,2]示例 2：输入：root = []输出：[]示例 3：输入：root = [1]输出：[1]
剑指offer编程题找出二叉树中序遍历的下一个结点Java实现（二叉树，中序遍历）
C137leo的博客
05-24 452
编程题找出二叉树中序遍历的下一个结点Java实现题目描述问题分析代码及讲解总结 题目描述 给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。 问题分析 二叉树的结构如下所示，题目中的描述next意思是指向当前节点的父节点。我们要知道中序遍历的含义，先按中序遍历左子树，再输出当前结点，然后再中序遍历右子树。 public class TreeLinkNode { int val; TreeLinkNode le
Cracking coding interview (4.5)二叉树按中序遍历次序返回某节点下一个节点
u011559205的专栏
08-03 639
4.5 Write an algorithm to find the ‘next’ node (e.g., in-order successor) of a given  node in a binary search tree where each node has a link to its parent.
94. 二叉树的中序遍历(java)
大河的博客
11-11 2008
题目描述 给定一个二叉树的根节点 root ，返回它的 中序 遍历。 首先是递归方法。 访问顺序：先左子树，再根节点，最后右子树； 原理：要先观察最后一个，从后往前进行分析。 随后进入D的右节点，运行inorder(res,root.right);D的右节点为空，函数返回。 到这里当然没结束，会依次返回到B点E点，回到A点。 此时，A的左侧节点已经加入完了，接下来是A的右侧节点。 代码如下 class Solution { public List<Integer> inorderT
使用Java实现二叉树的创建和前序、中序、后序三种遍历
weixin_58258124的博客
03-10 897
今天复习了一下二叉树，自己试着用代码实现了一下二叉树的创建和三种遍历，既是巩固一下二叉树的要点，也是练习一下java代码，毕竟有时间没有写代码了（都快忘了咋写了） 1.节点类 package Tree; /** * 节点类 */ public class Node { private char data; //数据就用字符表示，访问节点数据就是用打印字符代替 private Node lchild;//左节点 private Node rchild;//右节点
二叉树 非递归前中后序遍历 C语言
04-17
二叉树 非递归前中后序遍历汇总 C语言 希望大家给予建议
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
12-20
本文实例讲述了PHP基于非递归算法实现先序、中序及后序遍历二叉树操作。分享给大家供大家参考，具体如下： 概述： 二叉树遍历原理如下： 针对上图所示二叉树遍历： 1. 前序遍历：先遍历根结点，然后遍历左子树，...
Java实现的二叉树常用操作【前序建树，前中后递归非递归遍历及层序遍历】
08-28
主要介绍了Java实现的二叉树常用操作,包括二叉树的前序建树，前中后递归非递归遍历及层序遍历等相关操作技巧,需要的朋友可以参考下
用java 建立一棵二叉树，试编程实现二叉树的如下基本操作：1. 按先序序列构造一棵二叉链表表示的二叉树T；2. 对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出结点的遍历序列；
絔宝的博客
04-12 3444
建立一棵二叉树，试编程实现二叉树的如下基本操作： 1. 按先序序列构造一棵二叉链表表示的二叉树T； 2. 对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出结点的遍历序列； 3. 求二叉树的深度/结点数目/叶结点数目；
Java实现二叉树的遍历（先序、中序和后序）
m0_53676388的博客
01-24 1000
1、用先序方法建立一棵二叉树； 2、实现输出二叉树先序、中序和后序遍历序列中第k个数据元素的操作； 3、实现判断二叉树是否是完全二叉树的操作。
二叉树的Java实现以及前中后序遍历
cmdos的专栏
03-23 242
树的概念及结构树的概念树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根在上，而叶在下的。有一个特殊的结点，称为根结点，根节点没有前驱结点。除根节点外，其余结点被分成m(m > 0)个互不相交的集合T1、T2、…… 、Tm，其中每一个集合Ti(1 <= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，但可以有0个或多个后继。由此可知，树是递归定义的。下面是一个简单的树。
Java二叉树的创建以及遍历
AXibaaa的博客
08-05 401
1.二叉树的实现 二叉树的实现要比普通树容易，因为其每个节点最多只有两个子节点 其实，二叉树的每个左右子节点仍是一颗二叉树，因此，我们可以使用递归的方式来定义二叉树，二叉树的实现代码如下 public class BinaryTreeNode { private int data; //数据 private BinaryTreeNode leftChirld; //左...
Java版二叉树的前序遍历查找、中序遍历查找和后序遍历查找
qq_37837621的博客
02-19 1871
文章收藏的好句子：任何挫折，如果无法彻底击败你，那一定会使你更强。目录1、二叉树的节点查找 1、1 前序遍历查找 1、2 中序遍历查找 1、3 后序遍历查找1、二叉...
JAVA数据结构与算法之二叉树查找（前中后三种）
iCanCode的博客
09-28 208
前言 最近面临毕业就业，在复习数据结构与算法，为了更好地掌握，加深印象，所以决定写一些博客来知识复现。 温馨提示：这篇博客可能不适合刚学数据结构的新手。 代码实现 package sjjg; public class BinarySearchTree { public static void main(String[] args) { // TODO Auto-generated method stub BinaryTree3 binaryTree = new BinaryTree3();
Java二叉查找树遍历（前序遍历，中序遍历，后序遍历）
timewilltell12的博客
03-30 2388
针对树这一数据结构的遍历问题主要有四种，前序遍历、中序遍历、后序遍历、层序遍历，我们主要说明一下二叉树前序、中序、后序的递归方式代码模板。 基本思想 前序遍历：根结点 —> 左子树 —> 右子树 中序遍历：左子树—> 根结点 —> 右子树 后序遍历：左子树 —> 右子树 —> 根结点 前序遍历 //前序遍历 //获取整个树中所有的键 public Queue<Key> preErgodic(){ Queue&l
java实现二叉查找树
blue_x2的博客
10-10 1041
二叉查找树性质 ​ 开始这篇文章之前，首先我们回顾一下链表和数组元素查找方式，链表和数组查找某个元素必须从头节点往后遍历依次查找元素。这样的查找效率非常的低，如果使用二叉查找树则可以大大提高查找效率，接下来我们看看二叉查找树的创建规则。 二叉查找树的性质和规则 ​ 首先我们来看看二叉查找树是什么：它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。
Java实现二叉树的创建与四种遍历方式（前，中，后，层）
勇敢牛牛，不怕困难！
01-16 1719
​ 这里我们需要理解二叉树中会存储3个值，分别为自己本身的val值和两个指针，这两个指针分别会指向两个新的节点，或者指向为空。
二叉树（从建树、遍历到存储）Java
热门推荐
dabusiGin的博客
11-06 1万+
目录一、结构二、二叉树的遍历1.前序遍历（递归+非递归）2.中序遍历（递归+非递归）3.后序遍历（递归+非递归）4.层次遍历代码功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文......
课题三： 求二叉树上结点的路径 ■问题描述： 建立一棵二叉树，编程实现从根结点到给定结点之间的路径。 ■基本要求： 建立一棵以二叉链表存储的二叉树，以bt指向根节点、p指向任一给定结点，编程实现“以字符形式输出从根结点到给定结点之间的路径”。 ■测试数据： 自行建立一棵以序列｛A，B，C，D，E，F，G，H，I，J｝中的英文字母为结点的任意一棵二叉树。 ■实现提示： （1）以某种遍历方式建立二叉树的二叉链表存储结构； （2）以递归的后序方式遍历二叉树bt，并将访问过的结点依次存储到一个顺序栈S中； （3）当后序遍历访问到结点*p时，此时栈S中存放的所有结点均为给定结点*p的祖先，而由这些祖先，便构成了一条从根结点到结点*p之间的路径。
最新发布
06-09
// 后序遍历二叉树，并将访问过的结点依次存储到一个顺序栈中 private static void postorder(TreeNode root, TreeNode target, Stack<TreeNode> stack) { if (root == null) { return; } // 后序遍历左子树 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值