二叉树（遍历，查找，删除）

最新推荐文章于 2024-01-27 15:36:29 发布
最新推荐文章于 2024-01-27 15:36:29 发布
阅读量61 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rookie123222/article/details/118878690
版权

基本概念

1.结点，根结点，父结点，子结点，兄弟结点，叶子结点；

结点的度：结点的子结点个数；

结点层次：从根开始定义起，根为第一层，下面为第二层，以此类推；

树的深度：树中结点的最大层次。

2.满二叉树：除了叶子结点，每个结点度都为2。

3.完全二叉树：除去最后一层结点，二叉树为满二叉树；最后一层结点从左至右依次分布。

遍历

  • 前序遍历：root 开始，输出，向左递归->向右递归
  • 中序遍历：root开始，向左递归->输出->向右递归
  • 后续遍历：root开始，向左递归->向右递归->输出

 

//前序遍历
    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);
    }

查找

返回的节点为null说明没找到

//前序查找
    public HeroNode preSearch(int no){
        if (this.no==no)
            return this;
        HeroNode resNode=null;
        if (this.left!=null)
            resNode=this.left.preSearch(no);
        if (resNode!=null)
            return  resNode;
        if (this.right!=null)
            resNode=this.right.preSearch(no);
        return resNode;
    }
    //中序查找
    public HeroNode infixSearch(int no){
        HeroNode resNode=null;
        if (this.left!=null)
            resNode=this.left.infixSearch(no);
        if (resNode!=null)
            return resNode;
        if (this.no==no)
            return this;
        if (this.right!=null)
            resNode=this.right.infixSearch(no);
        return resNode;
    }
    //后序查找
    public HeroNode postSearch(int no){
        HeroNode resNode=null;
        if (this.left!=null)
            resNode=this.left.postSearch(no);
        if (resNode!=null)
            return resNode;
        if (this.right!=null)
            resNode=this.right.postSearch(no);
        if (resNode!=null)
            return resNode;
        if (this.no==no)
            return this;
        return resNode;
    }

删除结点

若待删除的是叶子节点，直接删除；若待删除的是子树的根节点，将子树删除

//删除节点(注意，删除节点后依然会遍历完其他节点；若想删除后即结束，应设返回值)
    //若待删除的是叶子节点，直接删除；若待删除的是子树的根节点，将子树删除
    public void delete(int no){
        if (this.left != null && this.left.no == no){
            this.left = null;
            return;
        }
        if (this.right !=null&&this.right.no == no){
            this.right = null;
            return;
        }
        if (this.left != null){
            this.left.delete(no);
        }
        if (this.right != null){
            this.right.delete(no);
        }
    }

完整代码

public class BinaryTree {
    public static void main(String[] args) {
        BinaryTree1 binaryTree = new BinaryTree1();
        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,"关胜");
        HeroNode node6=new HeroNode(6,"关胜");
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        node2.setLeft(node6);
        binaryTree.srtRoot(root);
        binaryTree.preOrder();
        binaryTree.delete(3);
        System.out.println("***************");
        binaryTree.preOrder();
    }
}
class BinaryTree1{
    private HeroNode root;
    public void srtRoot(HeroNode root){
        this.root=root;
    }
    //前序遍历
    public void preOrder(){
        if (this.root!=null)
            this.root.preOrder();
        else System.out.println("tree is empty");
    }
//    中序遍历
    public void infixOrder(){
        if (this.root!=null)
            this.root.infixOrder();
        else System.out.println("tree is empty");
    }
    //后序遍历
    public void postOrder(){
        if (this.root!=null)
            this.root.postOrder();
        else System.out.println("tree is empty");
    }
    //前序查找
    public void preSearch(int no){
        if (this.root!=null) {
            HeroNode heroNode = this.root.preSearch(no);
            if (heroNode==null)
                System.out.println("cant find");
            else
                System.out.println(heroNode);
        } else System.out.println("tree is empty");
    }
    //中序查找
    public void infixSearch(int no){
        if (this.root!=null) {
            HeroNode heroNode = this.root.infixSearch(no);
            if (heroNode==null)
                System.out.println("cant find");
            else
                System.out.println(heroNode);
        } else System.out.println("tree is empty");
    }
    //后序查找
    public void postSearch(int no){
        if (this.root!=null) {
            HeroNode heroNode = this.root.postSearch(no);
            if (heroNode==null)
                System.out.println("cant find");
            else
                System.out.println(heroNode);
        } else System.out.println("tree is empty");
    }
    //删除结点
    public void delete(int no){
        if (root != null){
            if (root.getNo() == no)
                root =null;
            else
                root.delete(no);
        }
        else
            System.out.println("tree is empty");
    }

}
class HeroNode{
    private  int no;
    private String name;
    private HeroNode left;
    private HeroNode right;
    public HeroNode(int no,String name){
        this.no=no;
        this.name=name;
    }

    public int getNo() {
        return no;
    }

    public String getName() {
        return name;
    }

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

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

    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 preSearch(int no){
        if (this.no==no)
            return this;
        HeroNode resNode=null;
        if (this.left!=null)
            resNode=this.left.preSearch(no);
        if (resNode!=null)
            return  resNode;
        if (this.right!=null)
            resNode=this.right.preSearch(no);
        return resNode;
    }
    //中序查找
    public HeroNode infixSearch(int no){
        HeroNode resNode=null;
        if (this.left!=null)
            resNode=this.left.infixSearch(no);
        if (resNode!=null)
            return resNode;
        if (this.no==no)
            return this;
        if (this.right!=null)
            resNode=this.right.infixSearch(no);
        return resNode;
    }
    //后序查找
    public HeroNode postSearch(int no){
        HeroNode resNode=null;
        if (this.left!=null)
            resNode=this.left.postSearch(no);
        if (resNode!=null)
            return resNode;
        if (this.right!=null)
            resNode=this.right.postSearch(no);
        if (resNode!=null)
            return resNode;
        if (this.no==no)
            return this;
        return resNode;
    }
    //删除节点(注意，删除节点后依然会遍历完其他节点；若想删除后即结束，应设返回值)
    //若待删除的是叶子节点，直接删除；若待删除的是子树的根节点，将子树删除
    public void delete(int no){
        if (this.left != null && this.left.no == no){
            this.left = null;
            return;
        }
        if (this.right !=null&&this.right.no == no){
            this.right = null;
            return;
        }
        if (this.left != null){
            this.left.delete(no);
        }
        if (this.right != null){
            this.right.delete(no);
        }
    }
}

rookie123222
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树遍历与删除
Richard_Cai
09-20 9097
前面写过二叉树的节点插入与查找关键数据项以及最值的数据项。二叉树的删除与遍历是另外一项重要的操作。特别是二叉树的人删除比较复杂，分为无子节点的节点删除，只有一个子节点的节点删除和有两个子节点的节点删除三种情况。1. 删除没有子节点的节点      这种情况是三种节点删除中最简单的。因为没有子节点的节点删除时只需要将该节点的左或者右节点的引用置为null即可。其他的基本不用变。可以下图表示：原始二叉树
二叉树的遍历、查找与删除
lxk116688的博客
02-14 318
为什么需要树这种数据结构？ （1）数组存储方式的分析 优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找检索速度。 缺点：如果要检索具体某个值，或者插入值（按一定顺序）会在整体移动，效率较低。 （2）链式存储方式的分析 优点：在一定程度上对数组存储方式有优化（比如：插入一个节点，只需要将插入节点链接到链表即可，删除效率也很好） 缺点：在进行检索时，效率仍然较低，比如（检索某个值，需要从头节点开始遍历） （3）树存储方式的分析 能提高数据存储，读取的效率，比如利用二叉排序树，既可以保证数据的检
【数据结构与算法】二叉树的创建，插入，遍历，删除，删除节点实现
码农code之路
07-10 5530
二叉树是每个结点最多有两个子树的树结构。使用广泛，使用C来实现对二叉树的操作。 示例：代码实现构造如下二叉树 #include <iostream> using namespace std; typedef struct BinaryTree { int data; struct BinaryTree* lchild; struct BinaryTree* rch...
二叉树的遍历与查找(详细笔记)
小吴
01-22 2313
博客主页小吴_小吴有想法_CSDN博客-leetcode,笔记,java领域博主 欢迎关注点赞收藏和留言 天道酬勤，勤能补拙，和小吴一起加油吧 17岁大一新生，水平有限，恳请各位大佬指点，不胜感激! 参考书籍：《算法4》，学习视频:尚硅谷Java数据结构与java算法（Java数据结构与算法）_哔哩哔哩_bilibili 目录 为什么有二叉树 二叉树的遍历 代码实现 二叉树——查找指定结点 前序查找思路 中序查找思路 后序查找思...
二叉树遍历与查找简单删除
Daylight629博客
11-16 126
二叉树遍历与查找、简单删除 一、遍历 使用前序，中序和后序对下面的二叉树进行遍历. 前序遍历: 先输出父节点，再遍历左子树和右子树 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点 小结: 看输出父节点的顺序，就确定是前序，中序还是后序 二、查找 三、简单删除 如果删除的节点是叶子节点，则删除该节点 如果删除的节点是非叶子节点，则删除该子树. //二叉树 class BinaryTree { //根结点 private
一文搞懂二叉树遍历---超详解（二叉树逐步剖析二）
热门推荐
weixin_64067830的博客
04-27 5万+
二叉树遍历一文搞懂，快过来看看吧
java中的二叉树遍历
最新发布
sutingStart的博客
01-27 1067
抛出几个问题java中什么是二叉树？在java中怎么体现？怎么进行增删改查？
韩顺平数据结构二叉树遍历查找删除笔记
weixin_52688663的博客
12-20 165
二叉树遍历查找删除笔记 遍历：前序中序后序 查找：前序中序后序 图解思路： 1）遍历 2）查找： 3）删除： 代码实现： package Tree; /** * 二叉树的前序中序后序遍历 * 主要利用递归思想 */ public class BinaryTreeDemo { public static void main(String[] args) { binaryTree binaryTree = new binaryTree(); ...
【数据结构与算法】9.1、二叉树 遍历查找 删除
日拱一卒，不期速成！
10-13 367
1、为什么需要树这种数据结构 1).数组存储方式的分析 优点：通过下标方式访问元素，速度快，对于有序数组，还可以使用二分查找提高检索速度。 缺点：如果要检索具体某个值，或者插入值会整体移动，效率低。 2).链式存储方式的分析 优点：在一定程度上对数组存储方式有优化(比如 插入一个数据节点，只需要将插入节点直接插入到链表中...
【数据结构】二叉树遍历与路径查找
weixin_52553215的博客
01-04 1052
#include<stdio.h> #include<string.h> #include<conio.h> //内含getch() #include<iostream> #include<malloc.h> //内含malloc typedef struct BinTNode{ char data; struct BinTNode *lchild , *rchild; }BinTNode, *BinTree; ...
二叉树遍历，c语言 实现数据结构二叉树遍历
04-19
二叉树遍历是计算机科学中数据结构领域的重要概念，主要应用于树形数据结构的处理。在C语言中实现二叉树遍历涉及到对指针的熟练操作和递归理解。下面将详细介绍二叉树的三种基本遍历方法：前序遍历、中序遍历和后序...
数据结构实验 二叉树遍历与路径查找
07-18
本实验“数据结构实验：二叉树遍历与路径查找”着重探讨了如何用C/C++语言实现二叉树的遍历和路径查找功能。 首先，我们来理解二叉树的基本概念。二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常...
二叉树的遍历实验报告.pdf
11-11
遍历二叉树是为了访问树中的所有节点，按照特定的顺序执行操作，如查找、插入或删除节点。在二叉树的应用中，遍历常用于解决问题，如查找特定属性的节点，或者对所有节点进行统一处理。遍历规则主要有三种： - 先序...
二叉树_二叉树遍历_二叉树_
10-04
3. 查找：在二叉树中查找特定值的节点，同样从根节点开始，根据节点值与目标值的比较决定向左子树还是右子树继续查找，直到找到目标值或者遍历到空节点为止。 二叉树的遍历是其核心操作之一，主要包括前序遍历、...
二叉树_C++_二叉树遍历_Vc_
09-29
**前序遍历**是二叉树遍历的一种方法，按照“根-左-右”的顺序访问每个节点。在C++中，前序遍历可以递归地实现，首先访问根节点，然后分别对左子树和右子树进行前序遍历。 **中序遍历**遵循“左-根-右”的顺序，常...
Huffman霍夫曼树，霍夫曼编码
rookie123222的博客
07-22 1962
霍夫曼树基本概念： 路径：从一个结点往下到孩子或孙子结点之间的同理 路径长度：如结点1到结点7的路径长度=2 结点的权：将结点的某一属性值作为结点的权 带权路径长度：从根节点到该结点*该结点的权；如结点1到结点7的带权路径长度：7*2=14 的带权路径长度（WPL）：该树的所有叶子结点的带权路径长度之和 霍夫曼树：给定n个权值，构造一颗二叉树并由这n个权值作为数的叶子结点，且该树的带权路径长度（WPL）达最小，这样的二叉树成为最优二叉树，也叫霍夫曼树 霍夫曼树特点：权值越大的叶子结点.
线索二叉树（以中序为例）
rookie123222的博客
07-20 748
基本介绍： （1）线索二叉树需为完全二叉树；加上了线索的二叉树为线索二叉树，根据线索性质不同，分为前序线索二叉树、中序线索二叉树、后序线索二叉树 （2）结点的前一个结点为前驱结点；结点的后一个结点为后继结点 如8的前驱结点为null，后继结点为3 中序线索化： 中序遍历：4,2,5,1,6,3 Thread(4):设置4.left=null ,pre=4 Thread(2):设置4.right=2,pre=2 Thread(5):设置5.left=2,pre=5 Threa..
最小生成树：prim普里姆算法+Kruskal科鲁斯卡尔算法（修路问题为例）
rookie123222的博客
08-01 628
Prim算法： 普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex ），且其所有边的权值之和亦为最小。 最小生成树： 题目（修路问题）： public class primAlgorithm { public static void main(String[] args) { char[] data = new char[]{'A', 'B', '..
贪心算法（以集合覆盖问题为例）
rookie123222的博客
07-31 431
概念： 贪心算法一般按如下步骤进行： ①建立数学模型来描述问题 ②把求解的问题分成若干个子问题 ③对每个子问题求解，得到子问题的局部最优解 ④把子问题的解局部最优解合成原来解问题的一个解 题目及思路： 第一次选覆盖地区最多的台（最优解），再将该台中包含的地区在其他台中划掉； 第二次选覆盖地区最多的台（最优解），在将该台中包含的地区在其他台中划掉…… ...
二叉树遍历与操作：查找、插入与删除
前序遍历适用于已知根节点的情况，中序遍历常用于查找二叉搜索树中的节点，而后序遍历则对整个树的结构更为敏感。在实际应用中，可以根据具体需求选择合适的遍历方式来找到目标节点。 线索二叉树是一种改进的二叉树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值