数据结构 - 二叉树(前序中序后序查找)

最新推荐文章于 2022-12-29 16:29:33 发布
最新推荐文章于 2022-12-29 16:29:33 发布
阅读量435 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 二叉树查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43736084/article/details/104144951
版权

在这里插入图片描述

    public static int i = 1, j = 1, k =1;
    //编写前序查找方法
    public HeroNode preOrderSearch(int no){
        System.out.println("前序遍历"+(i++)+"次");
        if (this.no == no){
            return this;
        }
        HeroNode heroNode = null;
        if (this.left != null){
            heroNode = this.left.preOrderSearch(no);
        }
        //不等于空说明在左边找到了
        if (heroNode != null){
            return heroNode;
        }
        if (this.right != null){
            heroNode = this.right.preOrderSearch(no);
        }
        return heroNode;
    }

    //中序遍历查找
    public HeroNode infixOrderSearch(int no){

        HeroNode heroNode = null;
        //先判断当前节点的左子节点是否为空，不为空继续进行中序查找
        if (this.left != null){
            heroNode = this.left.infixOrderSearch(no);
        }
        if (heroNode != null){
            return heroNode;
        }
        System.out.println("中序遍历"+(j++)+"次");
        if (this.no == no){
            return this;
        }
        if (this.right != null){
            heroNode = this.right.infixOrderSearch(no);
        }

        return heroNode;
    }

    //后序遍历查找
    public HeroNode postOrderSearch(int no){

        HeroNode heroNode = null;
        //判断当前节点的左子节点是否为空，不为空，则递归后序遍历查找
        if (this.left != null){
            heroNode = this.left.postOrderSearch(no);
        }
        if (heroNode != null){
            return heroNode;
        }
        //判断当前节点的右子节点是否为空，不为空，则递归后序遍历查找
        if (this.right != null){
            heroNode = this.right.postOrderSearch(no);
        }
        if (heroNode != null){
            return heroNode;
        }
        System.out.println("后序遍历"+(k++)+"次");
        //左右子树都没有找到，比较当前节点是不是
        if (this.no == no){
            return this;
        }
        return heroNode;
    }

 //前序查找
    public HeroNode preOrederSearch(int no){
        if (root != null){
            return root.preOrderSearch(no);
        }else {
            return null;
        }
    }
    //中序查找
    public HeroNode infixOrderSeach(int no){
        if (root != null){
            return root.infixOrderSearch(no);
        }else {
            return null;
        }
    }
    //后序查找
    public HeroNode postOrderSeach(int no){
        if (root != null){
            return root.postOrderSearch(no);
        }else {
            return null;
        }
    }

完整代码

package tree;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        //先需要创建一颗二叉树
        BinaryTree binaryTree = new BinaryTree();

        //创建需要的节点
        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");
        HeroNode node5 = new HeroNode(5, "关胜");

        //说明，先手动创建该二叉树，后面学习递归方式创建二叉树
        binaryTree.setRoot(root);
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);

        //测试
//        System.out.println("前序遍历");
//        binaryTree.preOrder();
//        System.out.println("中序遍历");
//        binaryTree.infixOrder();
//        System.out.println("后序遍历");
//        binaryTree.postOrder();

        //测试查找
        //前序遍历查找
        System.out.println("前序遍历查找：~~~~");
        HeroNode heroNode1 = binaryTree.preOrederSearch(5);
        if (heroNode1 != null){
            System.out.println("找到节点：" + heroNode1.toString());
        }else {
            System.out.println("没有找到");
        }

//        //中序遍历查找
        System.out.println("中序遍历查找：~~~~");
        HeroNode heroNode2 = binaryTree.infixOrderSeach(5);
        if (heroNode2 != null){
            System.out.println("找到节点：" + heroNode2.toString());
        }else {
            System.out.println("没有找到");
        }

        //后序遍历查找
        System.out.println("后序遍历查找：~~~~");
        HeroNode heroNode3 = binaryTree.postOrderSeach(5);
        if (heroNode3 != null){
            System.out.println("找到节点：" + heroNode3.toString());
        }else {
            System.out.println("没有找到");
        }

    }
}

class BinaryTree{
    private HeroNode root;
    public void setRoot(HeroNode root){
        this.root = root;
    }
    //前序遍历
    public void preOrder(){
        if (this.root != null){
            this.root.preOrder();
        }else {
            System.out.println("二叉树为空无法遍历");
        }
    }

    //中序遍历
    public void infixOrder(){
        if (this.root != null){
            this.root.infixOrder();
        }else {
            System.out.println("二叉树为空无法遍历");
        }
    }
    //后序遍历
    public void postOrder(){
        if (this.root != null){
            this.root.postOrder();
        }else {
            System.out.println("二叉树为空无法遍历");
        }
    }

    //前序查找
    public HeroNode preOrederSearch(int no){
        if (root != null){
            return root.preOrderSearch(no);
        }else {
            return null;
        }
    }
    //中序查找
    public HeroNode infixOrderSeach(int no){
        if (root != null){
            return root.infixOrderSearch(no);
        }else {
            return null;
        }
    }
    //后序查找
    public HeroNode postOrderSeach(int no){
        if (root != null){
            return root.postOrderSearch(no);
        }else {
            return null;
        }
    }

}
class HeroNode{
    private int no;
    private String name;
    private HeroNode left;//默认null
    private HeroNode right;//默认null;

    public HeroNode(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 HeroNode getLeft() {
        return left;
    }

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

    public HeroNode getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
    //编写前序遍历方法
    public void preOrder(){
        System.out.println(this);//先输出父节点
        //递归向左子树前序遍历
        if (this.left != null){
            this.left.preOrder();
        }
        //递归向右子树前序遍历
        if (this.right != null){
            this.right.preOrder();
        }
    }
    //编写中序遍历方法
    public void infixOrder(){

        //递归向左子树前序遍历
        if (this.left != null){
            this.left.infixOrder();
        }

        System.out.println(this);//输出父节点

        //递归向右子树前序遍历
        if (this.right != null){
            this.right.infixOrder();
        }
    }
    //编写后序遍历方法
    public void postOrder(){
        if (this.left != null){
            this.left.postOrder();
        }

        if (this.right != null){
            this.right.postOrder();
        }
        System.out.println(this);
    }
    public static int i = 1, j = 1, k =1;
    //编写前序查找方法
    public HeroNode preOrderSearch(int no){
        System.out.println("前序遍历"+(i++)+"次");
        if (this.no == no){
            return this;
        }
        HeroNode heroNode = null;
        if (this.left != null){
            heroNode = this.left.preOrderSearch(no);
        }
        //不等于空说明在左边找到了
        if (heroNode != null){
            return heroNode;
        }
        if (this.right != null){
            heroNode = this.right.preOrderSearch(no);
        }
        return heroNode;
    }

    //中序遍历查找
    public HeroNode infixOrderSearch(int no){

        HeroNode heroNode = null;
        //先判断当前节点的左子节点是否为空，不为空继续进行中序查找
        if (this.left != null){
            heroNode = this.left.infixOrderSearch(no);
        }
        if (heroNode != null){
            return heroNode;
        }
        System.out.println("中序遍历"+(j++)+"次");
        if (this.no == no){
            return this;
        }
        if (this.right != null){
            heroNode = this.right.infixOrderSearch(no);
        }

        return heroNode;
    }

    //后序遍历查找
    public HeroNode postOrderSearch(int no){

        HeroNode heroNode = null;
        //判断当前节点的左子节点是否为空，不为空，则递归后序遍历查找
        if (this.left != null){
            heroNode = this.left.postOrderSearch(no);
        }
        if (heroNode != null){
            return heroNode;
        }
        //判断当前节点的右子节点是否为空，不为空，则递归后序遍历查找
        if (this.right != null){
            heroNode = this.right.postOrderSearch(no);
        }
        if (heroNode != null){
            return heroNode;
        }
        System.out.println("后序遍历"+(k++)+"次");
        //左右子树都没有找到，比较当前节点是不是
        if (this.no == no){
            return this;
        }
        return heroNode;
    }
}

后序遍历查找最快

春_
关注
专栏目录
一文彻底搞定二叉树的前序、中序、后序遍历(图解递归非递归)
bigsai
09-22 1万+
前言 大家好，我是bigsai，在数据结构与算法中，二叉树无论是考研、笔试都是非常高频的考点内容，在二叉树中，二叉树的遍历又是非常重要的知识点，今天给大家讲讲二叉树的层序遍历。 这部分很多人可能会但是需要注重一下细节。 前面介绍了二叉排序树的构造和基本方法的实现，遍历也是比较重要的一环，并且二叉树的层序遍历也是bfs的最简单情况，这里我就将二叉树的层序遍历以及常考问题给大家分享一下。 在了解二叉树的遍历之前，需要具备数据结构与算法有队列、递归、栈、二叉树，这些内容咱们前面都有讲过，有这方面知识欠缺的同学可以
二叉树前中后序遍历及查找
xiaowanziddd的博客
02-06 940
二叉树前中后序遍历及查找 一、二叉树前中后序遍历 1、前序遍历：根结点 —> 左结点 —> 右结点 2、中序遍历：左结点 —> 根结点 —>右结点 3、后序遍历：左结点 —> 右结点 —>根结点 public class BinaryTreeDemo { public static void main(String[] args) { BinaryTree binaryTree = new BinaryTree(); HeroNod
二叉树-前中后序查找
ytc958374686的博客
12-24 86
public class BinaryTreeSearch { public static void main(String[] args) { //创建一颗二叉树 BinarySearch binarySearch = new BinarySearch(); //创建需要的节点 Data root = new Data(0...
二叉树的前序中序后序查找
weixin_52725999的博客
08-09 260
13.1.1 二叉树-查找指定节点 要求： 请编写前序查找，中序查找和后序查找 并分别使用三种查找方式，查找Node的id = 5 的节点 并分析各种查找方式，分别比较了多少次 思路： 前序查找： 先判断当前节点的id是否是要查找的 如果相等，则返回当前节点 如果不相等，则判断当前节点的左节点是否为空，如果不为空，则递归前序查找 如果左递归前序查找，找到节点则返回，否则判断，当前的节点的右子节点是否为空，如果不空，则继续向右递归前序查找 中序查找 判断当前节点的左节点是否为空，如果不为空，
【数据结构：树】二叉树---前、中、后序查找
JH灰色的博客
04-09 164
public class BinaryTreeDemo { public static void main(String[] args) { //创建一个二叉树 BinaryTree binaryTree = new BinaryTree(); //创建需要的节点 HeroNode root = new HeroNode(...
二叉树的查找（前/中/后序遍历查找）
qq_44111805的博客
02-05 1076
一、前序遍历查找‘ 1、判断当前结点的值是否等于需要查找的结点的值，若相等，则直接返回当前结点； 2、若不相等，则判断当前结点的左子结点是否为空，若不为空，则递归前序遍历查找； 3、若左递归前序遍历查找，可以找到结点，则直接返回该结点； 4、否则继续判断，当前的结点的右子结点是否为空，若不空，则继续向右递归前序遍历查找。 public TreeNode preOrderSearch(int val) { if(this.val==val) {//若当前结点为需要查找的结点,则直接返回 retu
erchashu.rar_前序 中序 后序
09-23
在IT领域，特别是数据结构和算法的学习中，二叉树是一种基本且重要的概念。二叉树是由节点（或称为顶点）构成的数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。这次我们要探讨的是二叉树的三种...
LastOrderTree.rar_LastOrderTree_前序 中序 后序
09-24
在IT领域，二叉树是一种基础且重要的数据结构，它由节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。在给定的“LastOrderTree.rar”压缩包中，包含了名为“LastOrderTree.C”的源代码文件，这很...
数据结构 二叉树链表结构 前序中序后序遍历
11-09
### 数据结构：二叉树链表结构及其遍历方法 #### 一、二叉树的基本概念 二叉树是计算机科学中的一个重要数据结构，它是一种非线性数据结构，每个节点最多有两个子节点，通常被称作左子节点和右子节点。在二叉树中...
九、二叉树-前序中序后序遍历、查找、删除
最新发布
AsiaLYF
12-29 799
数的常用术语、二叉树遍历、查找、删除节点
二叉树的前序、中序、后序查找
zt的博客
02-04 915
文章目录思路分析代码运行结果 思路分析 前序查找： 先判断当前结点的id是否等于要查找的id 如果是相等，则返回当前结点 如果不相等，则判断当前结点的左子节点是否为空，如果不为空，则递归前序查找左子树 如果左递归前序查找，找到结点，则返回，否继续判断，当前的结点的右子节点是否为空，如果不为空，则继续向右递归前序查找右子树. 这里我子介绍前序查找的思路，中序和后序查找的思路和前序查找的思路差不多 代码 /** * 模拟结点 */ public class Node { private int
94. 二叉树的中序遍历（中等题）
闭关修炼
12-20 243
题目描述： 给定一个二叉树，返回它的中序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注...
二叉树的前中后序查找
qq_45411328的博客
08-22 134
二叉树的查找 前序查找： 1.先找这个节点是不是满足条件的元素如果是就返回这个节点 2.如果这个节点的左子节点不为空就递归查找这个节点左子节点 3.如果在左子节点找到满足条件的元素就返回 4.如果左子节点没有找到那么递归查找右子节点，最后返回这个node（如果找不到的话这个node为null） //前序查找 public Node proSearch(int no){ if(this.no == no){ return this; } Node node = null; if(thi
二叉树的基本概念，二叉树的前中后序遍历
weixin_57711380的博客
12-20 542
基本概念 代码 package tree; //二叉树 public class BinaryTreeDemo { public static void main(String[] args) { //创建一颗二叉树 BinaryTree binaryTree = new BinaryTree(); //创建节点 HeroNode root = new HeroNode(1,"root号节点"); HeroNode node2 = new HeroN...
数据结构笔记_24 二叉树的前序、中序、后序查找
行者常至，为者常成
02-28 184
这一节，完成以下任务： 编写前序、中序、后序查找的方法。 使用三种方式，查找no为5的结点。 分析每种查找方式，分别比较了几次。 一、思路 与前面遍历的思路类似，直接上思路图解： 以 5号节点为例，不同顺序的查找方式，比较次数是不一样的。 前序需要4次比较才能找到5号节点，中序3次，后序2次。 二、代码 1、三种查找底层代码 // 前序遍历查找 /** * @param no 查找no * @return 找到就返回该Node，否则返回null */ public HeroNode p
二叉树前中后序遍历查找
DeathRS的博客
03-16 360
二叉树前序遍历查找 二叉树中序遍历查找 二叉树后续遍历查找 首先我们先看这张图片并进行短要的分析一下 这是一张示例图 根据前面我们学过的前中后序遍历我们可以通过前序遍历知道指针首先会找的是根结点 然后再找根结点的左边 再找根结点的右边的3然后找3的左边以及右边 所以输出的顺序是1,2,3,5,4 所以我们的前序查找也是根据这个顺序去查找 先直接上代码 //下面为实体类里面的代码块方法 pu...
二叉树的遍历(前序、中序、后序）和查找
qq_45974648的博客
02-16 446
文章目录1、二叉树简介2、二叉树遍历(前序、中序、后序）3、二叉树查找指定结点4、代码实现 1、二叉树简介 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。 二叉树的子节点分为左节点和右节点。 如果该二叉树的所有叶子节点都在最后一层，并且结点总数=2^n-1 , n为层数，则称为满二叉树。 完全二叉树是由满二叉树而引出来的，若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数(即1~h-1层为一个满二叉树)，第 h 层所有的结点都连续集中在最左
二叉树查找算法（前、中、后查找）
m0_57385165的博客
08-09 536
1.前序查找思路 先判断当前结点的no是否等于要查找的no 如果no相等，则返回该结点 如果no不相等，则判断当前结点的左子结点是否为空，如果不为空，则递归前序查找 如果左递归前序查找到结点，则返回 否则继续判断，当前结点的右子结点是否为空，如果不为空，则继续递归前序查找 2.中序查找思路 判断当前结点的左子结点是否存在，如果存在，则递归中序查找 如果找到，则返回当前结点 如果没有找到，继...
前序中序后序遍历转换方法详解
二叉树是一种重要的数据结构，它具有两个子节点的非空节点，常用于搜索、排序和表达语法结构等领域。本文主要探讨的是二叉树的三种基本遍历方式：前序遍历、中序遍历和后序遍历。这些遍历方法在算法设计中扮演着关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值