二叉树的创建、遍历、查找、删除

最新推荐文章于 2023-05-25 17:56:51 发布
最新推荐文章于 2023-05-25 17:56:51 发布
阅读量503 收藏 4
点赞数 1
分类专栏： Java数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43574446/article/details/105444451
版权

目录

二叉树结构的创建：

二叉树的遍历：

二叉树的查找:

二叉树的删除:

我们最初学习数据结构的时候，肯定是先从线性结构和链式结构讲起，回顾一下他们的特点。

线性结构以数组为例，它通过下标的方式访问元素，访问速度很快，但是当我们向数组中插入或删除某个元素时，会将插入位置的元素整体移动，从而造成效率低下。

链式结构以单链表为例，它在插入或删除元素时，只改变链表的指向并且不移动元素，能够解决线性结构插入或删除元素效率不足的问题，但是当我们需要访问某个元素时，只能从单链表头依次循环直到找到待访问元素为止，因此访问元素效率低下。

那么有没有哪种数据结构，既可以提高访问元素的速度，又可以提高插入或删除元素的效率呢?

它来了，能够提高数据存储和读取效率的树来了。以二叉排序树为例，它既可以保证数据的检索速度，又能够保证数据的插入、删除、修改的速度。

那么什么是二叉树呢? 每个节点最多只能有两个子节点的一种树称为二叉树。

二叉树又有满二叉树和完全二叉树：

有了二叉树的概念，就要用代码来实现它。

二叉树结构的创建：

二叉树拥有左右结点和父结点，根据这个特点来创建下图所示的二叉树结构。

  创建具有左右结点的单个结点：

class HeroNode{
    private int no;
    private String name;
    private HeroNode left; // 左结点
    private HeroNode right; // 右结点

    
    // 单个二叉树结点的操作
    // ...
}

创建带有头结点的二叉树：

class BinaryTree{
    private HeroNode root; // 头结点
    
    // 将单个结点的二叉树结点连接起来的操作
    // ...
}

二叉树的遍历：

前序遍历、中序遍历、后续遍历。三种遍历的区别在于，父结点所在的位置，父结点在前为前序遍历、在中为中序遍历、在后为后续遍历。前序遍历：父--->左--->右；中序遍历：左--->父--->右；后续遍历：右--->左--->父;

三种遍历的前提条件是初始化父结点root。

 前序遍历思路:

  1. 先输出当前结点(初始为root结点);
  2. 如果当前结点的左子结点不为空，则递归前序遍历；
  3. 如果当前结点的右子结点不为空，则递归前序遍历；

中序遍历思路:

  1. 如果当前结点的左子结点不为空，则递归中序遍历；
  2. 输出当前结点(初始为root结点);
  3. 如果当前结点的右子结点不为空，则递归中序遍历；

后序遍历思路:

  1. 如果当前结点的左子结点不为空，则递归后序遍历；
  2. 如果当前结点的右子结点不为空，则递归后序遍历；
  3. 输出当前结点(初始为root结点)； 
class BinaryTree{
    private HeroNode root; // 根结点

    public BinaryTree(HeroNode root){ // 指定根结点
        this.root = root;
    }

    // 前序遍历
    public void preOrder(){
        if (this.root != null){
            this.root.preOrder(); // 调用HeroNode中的前序遍历方法
        }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("二叉树为空，无法遍历");
        }
    }
}
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;
    }

    // 省略getter、setter方法以及toString方法

    // 前序遍历
    public void preOrder(){
        // 1.输出当前父结点
        System.out.println(this);
        // 2.如果当前结点的左子结点不为空，前序遍历
        if (this.left != null){
            this.left.preOrder();
        }
        // 3.如果当前结点的右子结点不为空，前序遍历
        if (this.right != null){
            this.right.preOrder();
        }
    }

    // 中序遍历
    public void infixOrder(){
        // 1.如果当前结点的左子结点不为空，中序遍历
        if (this.left != null){
            this.left.infixOrder();
        }
        // 2.输出当前父结点
        System.out.println(this);
        // 3.如果当前结点的右子结点不为空，中序遍历
        if (this.right != null){
            this.right.infixOrder();
        }
    }

    // 后序遍历
    public void postOrder(){
        // 1.如果当前结点的左子结点不为空，中序遍历
        if (this.left != null){
            this.left.infixOrder();
        }
        // 2.如果当前结点的右子结点不为空，中序遍历
        if (this.right != null){
            this.right.infixOrder();
        }
        // 3.输出当前父结点
        System.out.println(this);
    }
}
public class BinaryTreeDemo {
    public static void main(String[] args) {
        HeroNode heroNode1 = new HeroNode(1,"宋江"); 
        HeroNode heroNode2 = new HeroNode(2,"吴用"); 
        HeroNode heroNode3 = new HeroNode(3,"武松"); 
        HeroNode heroNode4 = new HeroNode(4,"林冲"); 
        BinaryTree binaryTree = new BinaryTree(heroNode1);// 指定根结点
        heroNode1.setLeft(heroNode2);    // 根节点的左子结点
        heroNode1.setRight(heroNode3);    // 根节点的右子结点
        heroNode3.setRight(heroNode4);    // 根节点的右子结点的右子结点
        // 遍历
        System.out.println("前序遍历：");
        binaryTree.preOrder(); //前序遍历
        System.out.println("中序遍历：");
        binaryTree.infixOrder(); //中序遍历
        System.out.println("后序遍历：");
        binaryTree.postOrder(); //后序遍历
    }
}

二叉树的查找:

查找的思路和遍历的思路类似，只是多了一步判断查找条件是否相等。查找也分为三种，前序查找、中序查找和后序查找，三种查找的区别还是根据处理父结点的顺序。

前序查找：

  1. 先判断当前结点的no值是否等于要查找的no值，如果相等，就返回当前结点；
  2. 如果不等，先判断当前结点的左结点是否为空，不为空就向左递归前序查找，如果找到，返回当前结点，
  3. 如果没找到，先判断当前结点的右子结点是否为空，不为空就向右子结点递归前序查找，如果找到，就返回当前结点，
  4. 没找到就返回null。
  5. 注：一定要有先判断左右结点是否为空这个条件，否则会出现空指针异常。

中序查找：

  1. 先判断当前结点的左子结点是否为空，不为空则向左结点递归中序查找，如果相等，就返回当前结点，
  2. 如果不等，就和当前结点比较，
  3. 如果当前结点和要查找的no值相等，就返回，不等就先判断右子节点是否为空，不为空则向右结点递归中序查找，
  4. 向右结点递归中序查找，找到就返回当前结点的右子结点，找不到返回null。

后序查找思路:

  1. 先判断当前结点的左子结点是否为空，不为空则向左结点递归后序查找，如果相等，就返回当前结点的左子结点，
  2. 如果不等，就判断当前结点的右子节点是否为空，如果不为空就向右子节点递归后序查找，
  3. 如果找到就返回，没找到就和当前结点比较，如果找到就返回，没找到就返回null。

class HeroNode{
    private int no;
    private String name;
    private HeroNode left; // 左结点
    private HeroNode right; // 右结点

    // 省略getter、setter和构造方法等

    // 查找：
    // 前序查找
    public HeroNode preOrderSearch(int id){
        // 1.判断id和当前结点是否相等
        if (this.no == id){
            return this;
        }
        // 2.当前结点没有找到，向左子结点递归前序查找
        HeroNode temp = null; // 用来接收递归是否找到相等元素
        if (this.left != null){
            temp = this.left.preOrderSearch(id);
        }
        // 向左子结点递归找到了
        if (temp != null){
            return temp;
        }
        // 3.当前左子结点没有找到，向右子结点递归前序查找
        if (this.right != null){
            temp = this.right.preOrderSearch(id);
        }
        // 返回右子结点是否找到，不用判断temp是否为null，可以在函数调用的地方来判断
        return temp;
    }
    // 中序查找
    public HeroNode infixOrderSearch(int id){
        // 1.当前结点的左子结点是否相等,判断是否找到
        HeroNode temp = null; // 用来判断递归结果是否找到
        if (this.left != null){
            temp =  this.left.infixOrderSearch(id);
        }
        if (temp != null){
            return temp;
        }
        // 2.当前结点是否相等
        if (this.no == id){
            return this;
        }
        // 3.当前结点的右子节点是否相等,判断是否找到
        if (this.right != null){
            temp = this.right.infixOrderSearch(id);
        }
        return temp;
    }

    // 后序查找
    public HeroNode postOrderSearch(int id){
        // 1.当前结点的左子结点是否相等,判断是否找到
        HeroNode temp = null; // 用来判断递归结果是否找到
        if (this.left != null){
            temp =  this.left.infixOrderSearch(id);
        }
        if (temp != null){
            return temp;
        }
        // 2.当前结点的右子节点是否相等,判断是否找到
        if (this.right != null){
            temp = this.right.infixOrderSearch(id);
        }
        if (temp != null){
            return temp;
        }
        // 3.当前结点是否相等
        if (this.no == id){
            return this;
        }
        return temp;
    }
}
class BinaryTree{
    private HeroNode root; // 根结点

    public BinaryTree(HeroNode root){ // 指定根结点
        this.root = root;
    }

    // 前序查找
    public HeroNode preOrderSearch(int id){
        if (this.root != null){
            return this.root.preOrderSearch(id);
        }
        return null;
    }
    // 中序查找
    public HeroNode infixOrderSearch(int id){
        if (this.root != null){
            return this.root.infixOrderSearch(id);
        }
        return null;
    }
    // 后序查找
    public HeroNode postOrderSearch(int id){
        if (this.root != null){
            return this.root.postOrderSearch(id);
        }
        return null;
    }
}
public class BinaryTreeDemo {
    public static void main(String[] args) {
        HeroNode heroNode1 = new HeroNode(1,"宋江"); // 根结点
        HeroNode heroNode2 = new HeroNode(2,"吴用"); // 根节点的左子结点
        HeroNode heroNode3 = new HeroNode(3,"武松"); // 根节点的右子结点
        HeroNode heroNode4 = new HeroNode(4,"林冲"); // 根节点的右子结点的右子结点
        BinaryTree binaryTree = new BinaryTree(heroNode1);
        heroNode1.setLeft(heroNode2);
        heroNode1.setRight(heroNode3);
        heroNode3.setRight(heroNode4);
       
        // 查找
        System.out.println("前序查找:");
        if (binaryTree.preOrderSearch(2) != null){
            System.out.println("找到了,"+binaryTree.preOrderSearch(2));// 前序查找
        }else {
            System.out.println("没有找到");
        }

        System.out.println("中序查找:");
        if (binaryTree.preOrderSearch(2) != null){
            System.out.println("找到了,"+binaryTree.infixOrderSearch(2));// 中序查找
        }else {
            System.out.println("没有找到");
        }

        System.out.println("后序查找:");
        if (binaryTree.preOrderSearch(2) != null){
            System.out.println("找到了,"+binaryTree.postOrderSearch(2)); // 后序查找
        }else {
            System.out.println("没有找到");
        }

    }
}

如果想要比较这三种查找的优越性，可以在if(this.no = id)上面添加一个变量来判断它们各自递归了几次，这里就不演示了。注意的是一定是在if(this.no = id)上，因为不论怎么递归最终目的都是判断当前结点是否相等。

二叉树的删除:

这里的删除指的是递归删除结点，我们暂且规定，（1）如果删除的结点是叶子结点，那么删除该节点；（2）如果删除的结点不是叶子结点，那么删除该子树。(当然我们可以把子节点转为根节点，这里先不讨论那种情况)

满足上面两个条件的删除结点的思路:

  1. 首先考虑，如果树是空树或者只有一个根节点root，直接将root置空即可，否则递归删除。
  2. 因为二叉树是单向的，所以我们判断当前结点的子结点是否为需要删除的结点，而不能去判断当前结点是不是需要删除的结点。（这是因为，二叉树单向，所以子结点找不到父结点,比如我们要删除5号，我们找不到5号的父结点，没法置为null）
  3. 如果当前结点的左子结点不为空，并且左子结点就是要删除的结点，就将this.left = null，然后返回，递归结束，
  4. 如果当前结点的右子结点不为空，并且右子结点就是要删除的结点，就将this.right = null，然后返回，递归结束，
  5. 如果3和4没有删除掉，就需要向左子树递归删除，
  6. 如果5还没有删掉，就需要向右子树递归删除。

class HeroNode{
    private int no;
    private String name;
    private HeroNode left; // 左结点
    private HeroNode right; // 右结点

    // 省略getter、setter和构造方法等

    
    /*  删除结点要求：（1）如果删除的结点是叶子结点，那么删除该节点；
                     （2）如果删除的结点不是叶子结点，那么删除该子树。
        0.首先考虑，如果树是空树或者只有一个根节点root，直接将root置空即可。
        我们把0放到BinaryTree中    */

    public void delNode(int id){
        // 1.如果当前结点的左子结点不为空，并且左子结点就是要删除的结点，就将this.left=null，然后递归结束
        if (this.left != null && this.left.no == id){
            this.left = null;
            return;
        }
        // 2.如果当前结点的右子结点不为空，并且右子结点就是要删除的结点，就将this.right=null，然后递归结束
        if (this.right != null && this.right.no == id){
            this.right = null;
            return;
        }
        // 3.如果1和2没有删除掉，就需要向左子树递归删除
        if (this.left != null){
            this.left.delNode(id);
        }
        // 4.如果3还没有删掉，就需要向右子树递归删除
        if (this.right != null){
            this.right.delNode(id);
        }
    }
}

class BinaryTree{
    private HeroNode root; // 根结点

    public BinaryTree(HeroNode root){ // 指定根结点
        this.root = root;
    }

   
    // 删除结点
    public void delNode(int id){
        // 0.首先考虑，如果树是空树或者只有一个根节点root，直接将root置空即可,否则递归删除
        if (this.root != null){
            if (root.getNo() == id){ //只有一个根节点root
                root = null;
            }else {
                root.delNode(id);
            }
        }else{
            System.out.println("二叉树为空，无法删除");
        }
    }
}
public class BinaryTreeDemo {
    public static void main(String[] args) {
        HeroNode heroNode1 = new HeroNode(1,"宋江"); // 根结点
        HeroNode heroNode2 = new HeroNode(2,"吴用"); // 根节点的左子结点
        HeroNode heroNode3 = new HeroNode(3,"武松"); // 根节点的右子结点
        HeroNode heroNode4 = new HeroNode(4,"林冲"); // 根节点的右子结点的右子结点
        HeroNode heroNode5 = new HeroNode(5,"李逵"); // 根节点的右子结点的右子结点
        BinaryTree binaryTree = new BinaryTree(heroNode1);
        heroNode1.setLeft(heroNode2);
        heroNode1.setRight(heroNode3);
        heroNode3.setLeft(heroNode4);
        heroNode3.setRight(heroNode5);

        int delNode = 2;
        System.out.println("删除二叉树中的结点:"+delNode);
        binaryTree.delNode(delNode);
        System.out.println("删除后的二叉树遍历:");
        binaryTree.preOrder();

    }
}

 

挖点代码拌西瓜
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的遍历实验报告.pdf
11-11
遍历二叉树是为了访问树中的所有节点，按照特定的顺序执行操作，如查找、插入或删除节点。在二叉树的应用中，遍历常用于解决问题，如查找特定属性的节点，或者对所有节点进行统一处理。遍历规则主要有三种： - 先序...
Python写数据结构:二叉树的创建和遍历
theLostLamb的博客
02-03 537
#!/usr/bin/python3.5 #_*_coding:utf-8_*_ class Node: def __init__(self,value): self.data = value self.lchild = None self.rchild = None class Tree: def __init__(self):
数据结构实验五 二叉树的建立及遍历应用
qq_66451743的博客
05-28 881
实验五二叉树的建立及遍历应用 一、【实验目的】 1、掌握二叉树的建立方法 2、掌握二叉树遍历的基本方法（先序、中序、后序） 3、掌握递归二叉树遍历算法的应用 二、【实验内容】 1.构造一棵二叉树,树的形态如下图所示，打印出先序遍历、中序遍历、后序遍历的遍历序列。 2.选择一种遍历方式计算该树中叶子结点的个数，并打印出叶子结点。 提示: 先根据给定的树，写出此树的扩展先序遍历序列，然后根据此遍历序列建立二叉树。 三、【实验源代码】 ...
二叉搜索树的删除
y632481222的博客
03-04 147
二叉搜索树的删除（7种情况）\n设待删除结点为cur，待删除结点的双亲结点为parent\n整体看分以下3种大情况：\n①cur的左为空\n②cur的右为空\n③cur的左和右都不为空\n继续细分：cur是不是root；cur不是root的话，是parent的左还是parent的右\n故有3 + 3 + 1 = 7种情况。\n\ncur.left == null\n①cur是root\n则 root = cur.right;\n②cur不是root，cur是parent.left\n则 parent.lef
数据结构和算法学习记录——二叉搜索树的插入操作、删除操作
li13437542099的博客
04-20 1135
这样处理的好处是：左子树的最大值一定不是有两个孩子节点的情况、而右子树的最小值也一定不是有两个孩子节点的情况。我们已经知道了没有孩子节点的情况和只有一个孩子节点的情况该怎么删除了，当有两个孩子节点的情况时，就考虑能不能把它变成只有一个孩子节点的情况来处理呢？当找到了新节点应该插入的位置时，需要通过找到上一个节点的地址，来将上一个节点的左子树指针或者右子树指针指向新节点。是可以实现的：用另一节点替代被删除的节点，这个节点应是右子树的最小元素或者左子树的最大元素。它形成的二叉搜索树是怎样的呢？
数据结构复习 ---- 链表（一）
weixin_44816732的博客
01-27 561
总结一些经验，对比链表这种链式存储结构和数组等一些顺序存储结构，其优势在于插入和删除比较方便，不影响其他的节点数据，但是也因为他不是一种连续的存储形式，在查找时需要遍历，所以选择使用哪种数据结构也要根据实际需要来权衡选择。没有最优的数据结构，只有最合适的数据结构。
erchashu.rar_ABC_二叉树的遍历_遍历
09-20
在本主题"erchashu.rar_ABC_二叉树的遍历_遍历"中，我们将深入探讨二叉树的遍历方法，包括先序遍历、中序遍历和后序遍历，这些方法对于理解和操作二叉树至关重要。 先序遍历（Preorder Traversal）是访问二叉树的一...
二叉树建立遍历
01-03
在实际应用中，二叉树遍历算法不仅限于简单的打印节点值，还可以用于查找、插入、删除等操作。例如，在二叉搜索树中，中序遍历可以快速找到一个特定的元素；而在构建表达式树时，后序遍历可以帮助我们求解表达式的值...
二叉树_二叉树遍历_二叉树_
10-04
3. 查找：在二叉树中查找特定值的节点，同样从根节点开始，根据节点值与目标值的比较决定向左子树还是右子树继续查找，直到找到目标值或者遍历到空节点为止。 二叉树的遍历是其核心操作之一，主要包括前序遍历、...
二叉树建立和查找 数据结构
06-22
数据结构中的二叉树建立和查找的功能的实现，对于平常的课程设计还是绰绰有余的。
Node.js-del-使用globs删除文件和文件夹
08-10
del - 使用globs删除文件和文件夹
搜索二叉树的各种操作 创建 查找 遍历 插入 删除
01-20
搜索二叉树的各种操作 创建 查找 遍历 插入 删除 在GCC下编译通过。
二叉搜索树（查找、插入、删除的讲解实现+图文并茂）
最新发布
bang___bang_的博客
05-25 7684
本文讲解并模拟实现二叉搜索树，详解它的查找、插入、删除及实现，并对二叉搜索树的应用场景进行描述，最后进行了性能分析！
二叉搜索树(Binary Search Tree)的深入剖析：代码+画图 详解插入、查找、删除操作
fufufu_的博客
04-30 1528
二叉搜索树深入剖析 详解插入查找删除操作
双向链表(2) - 删除节点
热门推荐
水草的专栏
06-14 1万+
双向链表(2) - 删除节点
二叉搜索树的删除操作详解，图文并茂，化繁为简
m0_46551861的博客
10-31 6222
档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np impo
二叉搜索树的创建，删除，查找
zhao_miao的博客
09-02 6964
二叉搜索树的概念   二叉搜索树又称二叉排序树，它或者是一颗空树，或者是具有以下性质的二叉树 若它的左子树不为空，则左子树上的所有结点的值都小于根结点的值。 若它的右子树不为空，则右子树上的所有结点的值都大于根节点的值。 它的左右子树也分别为二叉搜索树。 二叉搜索树的操作   查找关键字data：①.若根节点为空，即二叉搜索树为空。返回0。 ②.若data>根节点的da...
二叉搜索树的删除操作———完美适合初学者
m0_59610064的博客
04-05 3063
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、二叉搜索树是什么 二、思路分析 三、总结 前言 在二叉搜索树中的插入，查找相对来说较为容易，但其中的删除操作就相对复杂，下来我将为初学者提供二叉搜索树中删除操作的具体思路。 提示：以下是本篇文章正文内容，下面案例可供参考 一、二叉搜索树是什么？ 示例：若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值