二十六、二叉树--查找指定节点

最新推荐文章于 2024-07-28 17:42:24 发布
最新推荐文章于 2024-07-28 17:42:24 发布
阅读量372 收藏
点赞数
分类专栏： 数据结构与算法设计 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaozhiwei314/article/details/114273321
版权

一、通过前中后序遍历查找指定节点

  1. 请编写前序查找，中序查找和后序查找的方法。

  2. 并分别使用三种查找方式，查找 heroNO = 5 的节点

  3. 并分析各种查找方式，分别比较了多少次

  4. 思路分析图解

在这里插入图片描述

二、代码实现

package cn.zzw.algorithm.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,"关胜");

        //手动创建二叉树
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);

        binaryTree.setRoot(root);

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

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

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

        //测试先序遍历查找
        //先序遍历查找的次数：4次
        /*
        System.out.println("前序遍历方式");
        HeroNode resNode=binaryTree.preOrderSearch(5);
        if(resNode!=null)
        {
            System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
        }
        else
        {
            System.out.printf("没有找到 no = %d 的英雄", 5);
        }
        System.out.println("=========================");

         */

        //测试中序遍历查找
        //中序遍历查找的次数：3次
        /*
        System.out.println("中序遍历方式");
        HeroNode resNode=binaryTree.infixOrderSearch(5);
        if(resNode!=null)
        {
            System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
        }
        else
        {
            System.out.printf("没有找到 no = %d 的英雄", 5);
        }
        System.out.println("=========================");

         */

        //测试中序遍历查找
        //中序遍历查找的次数：2次
        System.out.println("后序遍历方式");
        HeroNode resNode=binaryTree.postOrderSearch(5);
        if(resNode!=null)
        {
            System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
        }
        else
        {
            System.out.printf("没有找到 no = %d 的英雄", 5);
        }
        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 preOrderSearch(int no)
    {
        if(root!=null)
        {
            return this.root.preOrderSearch(no);
        }
        else
        {
            return null;
        }
    }

    //进行中序遍历
    public HeroNode infixOrderSearch(int no)
    {
        if(root!=null)
        {
            return this.root.infixOrderSearch(no);
        }
        else
        {
            return null;
        }
    }

    //进行后序遍历
    public HeroNode postOrderSearch(int no)
    {
        if(root!=null)
        {
            return this.root.postOrderSearch(no);
        }
        else
        {
            return null;
        }
    }
}

//创建HeroNode结点，模拟树的结点
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 HeroNode preOrderSearch(int no)
    {
        System.out.println("进入先序遍历");
        //比较当前结点是不是要找的结点
        if(this.no==no)
        {
            return this;
        }
        //1.则判断当前结点的左子节点是否为空，如果不为空，则递归前序查找
        //2.如果左递归前序查找，找到结点，则返回
        HeroNode resNode=null;
        if(this.left!=null)
        {
            resNode=this.left.preOrderSearch(no);
        }
        if(resNode!=null)
        {
            //说明在左子树上找到该节点
            return resNode;
        }

        //1.左递归前序查找，找到结点，则返回，否继续判断
        //2.当前的结点的右子节点是否为空，如果不空，则继续向右递归前序查找
        if(this.right!=null)
        {
            resNode=this.right.preOrderSearch(no);
        }
        return resNode;
    }

    //中序遍历查找
    public HeroNode infixOrderSearch(int no)
    {
        HeroNode resNode=null;
        //判断当前结点的左子节点是否为空，如果不为空，则递归中序查找
        if(this.left!=null)
        {
            resNode=this.left.infixOrderSearch(no);
        }
        if(resNode!=null)
        {
            return resNode;
        }

        System.out.println("进入中序查找");
        //如果找到，则返回，如果没有找到，就和当前结点比较，如果是则返回当前结点
        if(this.no==no)
        {
            return this;
        }

        //否则向右进行递归查找
        if(this.right!=null)
        {
            resNode=this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    //进行后序遍历查找
    public HeroNode postOrderSearch(int no)
    {
        HeroNode resNode=null;
        if(this.left!=null)
        {
            resNode=this.left.postOrderSearch(no);
        }
        if(resNode!=null)
        {
            return resNode;
        }

        //如果左子树没有找到，则向右子树递归进行后序遍历查找
        if(this.right!=null)
        {
            resNode=this.right.postOrderSearch(no);
        }
        if(resNode!=null)
        {
            return resNode;
        }

        System.out.println("进入后序查找");
        //如果左右子树都没有找到，就比较当前结点是不是
        if(this.no == no)
        {
            return this;
        }
        return resNode;
    }
}

测试结果：

"C:\Program Files\Java\jdk1.8.0_181\bin\java.exe" "-javaagent:D:\IntelliJ IDEA\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=49893:D:\IntelliJ IDEA\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_181\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\rt.jar;C:\Users\1\IdeaProjects\algorithm\out\production\algorithm" cn.zzw.algorithm.Tree.BinaryTreeDemo
前序遍历
HeroNode{no=1, name='宋江'}
HeroNode{no=2, name='吴用'}
HeroNode{no=3, name='卢俊义'}
HeroNode{no=5, name='关胜'}
HeroNode{no=4, name='林冲'}
中序遍历
HeroNode{no=2, name='吴用'}
HeroNode{no=1, name='宋江'}
HeroNode{no=5, name='关胜'}
HeroNode{no=3, name='卢俊义'}
HeroNode{no=4, name='林冲'}
后序遍历
HeroNode{no=2, name='吴用'}
HeroNode{no=5, name='关胜'}
HeroNode{no=4, name='林冲'}
HeroNode{no=3, name='卢俊义'}
HeroNode{no=1, name='宋江'}
后序遍历方式
进入后序查找
进入后序查找
找到了，信息为 no=5 name=关胜=========================

Process finished with exit code 0
eligible-zzw
关注
专栏目录
数据结构笔记_23 二叉树的前序、中序、后序遍历(含重写toSring，this相关)
行者常至，为者常成
02-27 278
概念： 前序遍历：先输出父节点，再遍历左子树和右子树。 中序遍历：先遍历左子树，再输出父节点，再遍历右子树。 后序遍历：先遍历左子树，再遍历右子树，最后输出父节点。 小结：看输出父节点的顺序，就确定是前序，中序还是后序。 遍历步骤： 前序：根左右 中序：左根右 后序：左右根 代码 先创建一个 HeroNode 节点，里面包含基本属性、构造方法、各种遍历方法的底层代码。 再定义 BinaryTree 二叉树，在二叉树中调用相关的接口。 相当于节点提供具体的底层实现方法，树来进行调用。和前面的哈希表类
二叉树查找指定节点
实践求真知
03-18 923
一需求 1 编写前序查找，中序查找和后序查找的方法。 2 分别使用三种查找方式，查找 heroNO = 5 的节点。 3 分析各种查找方式，分别比较了多少次。 二 图解 三 代码 /** * @className: BinaryTreeDemo * @description: 二叉树实战 * @date: 2021/3/16 * @author: cakin */ public class BinaryTreeDemo { /** * 功能描述：二叉树测试 *.
二十五、二叉树的前序、中序、后序遍历
zhaozhiwei314的博客
03-01 192
一、为何使用树这种数据结构 数组存储方式的分析 优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。 缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低 [示意图] 链式存储方式的分析 优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)。 缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历) 树存储方式的分析 能提高数据存储，读取的效率, 比如利用 二叉排
二叉树的遍历（先序、中序、后序、层次）
kusunoki的博客
07-28 1万+
参照王道数据结构辅导书以及哔哩哔哩大学的部分视频，对二叉树遍历的重要知识点进行归纳，并总结做题技巧。
二叉树——查找指定节点
Blackoutdragon的博客
01-19 6667
二叉树——查找指定节点 前序查找 思路分析 先判断当前节点是否为要查找的节点，相等就返回当前节点，作为递归中值的条件 如果不相等，判断左子节点是否为空，不为空，递归前序查找 如果左递归前序查找，找到该节点，那就返回该节点 没找到，那就判定右子节点是否为空，不为空就进行右子节点的递归前序查找 代码实现 我的代码： public HeroNode preOrderSearch(int no){...
二叉树的前、中、后序遍历
热门推荐
ll1175555的博客
06-12 1万+
所谓二叉树遍历是按某种特定规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树进行其它运算的基础。二叉树的遍历有：前序/中序/后序的递归结构遍历：1. 前序遍历(先根遍历)——访问根结点的操作发生在遍历其左右子树之前（根->左子树->右子树）。2. 中序遍历(中根遍历)——访问根结点的操作发生在遍历其左右子树之中（左子树->根->右子树)。3. 后序遍历(后根遍历)——访问根结点的操作发生在遍历其左右子树之后（
二叉树--城市数据库.rar_数据结构 二叉树
09-24
二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点，这使得它非常适合执行搜索操作。 二叉树的主要特点和操作： 1. **定义**：二叉树是由根节点、若干个子节点（最多两个）...
js代码-二叉树中从根节点开始和为某值的路径
07-16
在JavaScript编程领域，二叉树是一种常见的数据结构，它由一系列节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。在实际问题中，二叉树常被用于实现各种算法，如搜索、排序等。本话题关注的是在...
js代码-12.1 二叉搜索树-查找指定节点
07-14
在JavaScript中实现二叉搜索树查找指定节点的过程通常包括以下步骤： 1. 定义节点类：创建一个Node类，包含值（value）、左子节点（left）和右子节点（right）属性。 ```javascript class Node { constructor...
数据结构-b类-红黑二叉树-毕业论文.doc
06-28
此外，还有辅助函数如`RBserach`用于查找指定键的节点，`RBMinimum`和`RBMaximum`用于找到树中的最小和最大元素，以及`RBpioneer`和`RBsucceed`用于找到给定节点的前驱和后继节点。 `LinkStack`结构定义了一个链栈...
【数据结构31】二叉树的前序，中序，后序遍历
你今天真好看呀
01-02 319
文章目录1. 树2. 树的常用术语3. 二叉树4. 二叉树的遍历5. 代码实现 1. 树 2. 树的常用术语 3. 二叉树 4. 二叉树的遍历 5. 代码实现 public class BinaryTreeDemo { public static void main(String[] args) { //创建一个二叉树 BinaryTree ...
树——二叉树的先序、中序和后序遍历
05-26 618
1，二叉树是否只有一种遍历方式（层次遍历）？ 2，典型的二叉树的遍历方式： 1，先序遍历（Pre-Order Traversal）； 2，中序遍历（In-Order Traversal）； 3，后序遍历（Post-Order Traversal）； 3，先序遍历（“先序”指最先访问根结点中的数据元素）： 　　1，二...
二叉树的前序,中序,后序遍历
zark721的博客
11-02 329
什么是二叉树？ 二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”和“右子树”，左子树和右子树同时也是二叉树。二叉树的子树有左右之分，并且次序不能任意颠倒。 因为忘记了关于树的遍历,所以现在做下笔记。 中序+前序  求 后序 //根据前序,中序,建立树,输出后序遍历的结果 #include #include struct Node { Node *lchild;
二叉树的先序中序后序介绍及代码
weixin_44410154的博客
11-05 813
二叉树的遍历介绍及代码 1.二叉树的介绍 例子：已知前序中序遍历求后序遍历 前序：A,B,D,H,I,E,J,K,C,F,L,M,G,N,O 中序：H,D,I,B,J,E,K,A,L,F,M,C,N,G,O 首先我们先根据前序可以判断出根节点为A，然后通过前序和后序可以画出来二叉树的分布图，再根据后序遍历的规则得出后序遍历为：H,I,D,J,K...
二叉树知识点、先序、中序、后序遍历（数据结构）
步履蹒跚的攻城狮的博客
07-01 1334
Reference： 1. 作者：小马 2. 作者：ggmghwp一 、二叉树的概念二叉树就是每个结点最多有两个子树的树形存储结构。 1、满二叉树和完全二叉树上图就是典型的二叉树，其中左边的图还叫做满二叉树，右边是完全二叉树。然后我们可以得出结论，满二叉树一定是完全二叉树，但是反过来就不一定。满二叉树的定义是除了叶子结点，其它结点左右孩子都有,深度为k的满二叉树，结点数就
二叉树-查找指定节点
Rong_zhe的博客
08-25 4652
二叉树查找指定节点思路 前序查找思路 当前节点是否为空，不为空判断当前节点的rank是否等于要查找的rank 若等于，则返回当前节点； 若不等于，则判断当前节点的左子节点是否为空， 如果不为空，则继续向左递归前序查找，如果左递归前序查找， 找到了节点，则返回； 若没找到，则继续判断当前节点的右子节点是否为空， 如果不为空，则继续向右递归前序查找，如果右递归前序查找，找到了节点，则返回。若没找到则为空。 /** * 树的节点 */ class TreeNode{ public int rank
二叉树~查找指定节点
qq_45058113的博客
04-13 911
要求： 1)请编写前序查找，中序查找和后序查找的方法。 2) 并分别使用手种查找方式，查找heroNo= 5的节点 3) 并分析各种查找方式，分别比较了多少次 思路如下： 代码实现： //二叉树的遍历:前序、中序、后序 public class BinaryTreeDemo { public static void main(String[] args) { //先需要创建一个二叉树 BinaryTree binaryTree = new BinaryTr.
红黑树从根出发，溯本求源
我是坏人哦
10-18 236
技术这种东西真的很奇妙，当你找到一个点去研究，然后就会发现带出来的知识点越来越多，越来越有趣。这个过程就跟反腐一样，抓到一个带出一窝，贼刺激！ 这不合适，换个比喻。这个过程就像挖宝藏一样。因为上一篇写HashMap，挖到了红黑树这个知识点一时间不知道怎么组织语言，然后就从红黑树开始往前顺着二叉排序树（BST）挖到了远古时代的二叉树，往后挖到了时下数据库索引流行的B-树和B+树，还有暂时不知道什么软件或框架有用到的B*树。 我也是最近才对“学无止境”这句话有了一点体会。以前我幼稚的看法是：技术它就在那里不.
二叉树 遍历 查找指定节点
qq_39813070的博客
11-27 423
【代码】二叉树 遍历 查找指定节点。
查找二叉树的指定节点所在层数
最新发布
10-02
查找二叉树（Binary Search Tree, BST）中的指定节点所在的层数可以通过深度优先搜索（Depth First Search, DFS）算法来计算。一种常见的做法是使用递归，从根节点开始，如果找到目标节点，则返回当前层级；如果没有找到，检查左子树还是右子树，根据查找到的目标节点是在当前节点的左边还是右边，确定是在下一层的左侧还是右侧继续递归。当遍历到空节点时，说明已经到达最底层。 以下是Python的一个简单示例： ```python def find_depth(root, target, level=0): if root is None or root.val == target: return level left_height = find_depth(root.left, target, level + 1) if root.left else -1 right_height = find_depth(root.right, target, level + 1) if root.right else -1 return max(left_height, right_height) # 使用方法 root = ... # 你的二叉树根节点 target_node_value = ... # 要查找的节点值 node_depth = find_depth(root, target_node_value) ``` 在这个函数中，`level`参数记录了当前节点的层级，`left_height`和`right_height`分别代表左子树和右子树的高度，最后取两者中的最大值即为目标节点所在的实际层次。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值