二叉树知识之3节点的删除

最新推荐文章于 2021-12-20 23:37:49 发布
最新推荐文章于 2021-12-20 23:37:49 发布
阅读量1.7k 收藏 12
点赞数 1
分类专栏： 数据结构 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56184347/article/details/119026768
版权

二叉树的删除

简单二叉树删除的思路

简单删除的规定

  1. 如果删除的是叶子节点，则删除该节点
  2. 如果删除的节点是非叶子节点，则将该节点的子树一起删除

简单删除的思路

  1. 先判断是是不是空树，是空树则直接返回，
  2. 该树的root节点是不是要删除的节点，如果是root节点，则直接将整个树置为null
  3. 删除时先找到该要删除的节点的上一个节点，如果当前节点的左子节点是要删除的节点，则将this.left=null并且返回（结束递归删除）
  4. 如果当前节点的右子节点不为空，且就是要删除的节点则将this.right=null;并且返回（结束递归删除）
  5. 如果第3，4步没有删除节点，则将左子树进行递归删除
  6. 如果第5步也没有删除节点，则应当向右子树进行递归删除

简单删除的代码实现（以删除4号节点为例）

找到4号节点并且删除4号节点时，在进行前序遍历时应该是1-2-3：下面进行仿真
删除4号节点为例

在节点中的简单删除

public void delete(int no){
        //* 3. 删除时先找到该要删除的节点的上一个节点，如果当前节点的左子节点是要删除的节点，则将this.left=null并且返回（结束递归删除）
        if(this.left!=null&&this.left.no==no){
            this.left=null;
            return;
        }
        //4. 如果当前节点的右子节点不为空，且就是要删除的节点则将this.right=null;并且返回（结束递归删除）
        if(this.right!=null&this.right.no==no){
            this.right=null;
            return;
        }
        //5如果第3，4步没有删除节点，则将左子树进行递归删除
        if(this.left!=null){
            this.left.delete(no);
        }
        //6. 如果第5步也没有删除节点，则应当向右子树进行递归删除
        if(this.right!=null){
            this.right.delete(no);
        }
    }

在二叉树的结构中进行删除的步骤实现

public void delete(int no){
        //先判断该树的根节点是否为空
        if(root!=null){
            //判断该根节点是否和目标一致，如果一致则直接删除，置为空
            if(root.no==no){
                root=null;
                //如果当前根节点不是要删除的节点，则需要递归删除
            }else {
                root.delete(no);
            }
         //如果为空则直接返回啦！
        }else {
            System.out.println("该树为空不能删除！");
            return;
        }
    }

测试代码

package com.njupt.binaryTree;

/**
 * Creat with IntelliJ IDEA
 *
 * @Auther:倔强的加瓦
 * @Date:2021/07/23/11:16
 * @Description:
 */
public class SimpleDelete {
    public static void main(String[] args) {

        BinaryTr binary = new BinaryTr();
        NodeND node1 = new NodeND(1, "吴吴");
        NodeND node2 = new NodeND(2, "亦亦");
        NodeND node3 = new NodeND(3, "凡凡");
        NodeND node4 = new NodeND(4, "签签");
        NodeND node5 = new NodeND(5, "word");
        NodeND node6 = new NodeND(6, "very big");
        node1.left = node2;
        node1.right = node4;
        node2.left = node3;
        node4.left = node5;
        node4.right = node6;
        //给根节点赋值
        binary.root = node1;
        System.out.println("没删除4号节点之前的前序遍历：");
        binary.preSearch();
        binary.delete(4);
        System.out.println("删除4号节点之后的前序遍历");
        binary.preSearch();

    }
}

class BinaryTr {
    public NodeND root;

    //前序遍历的方法
    public void preSearch() {
        if (root == null) {
            System.out.println("当前树为空");
            return;
        } else {
            this.root.pre();
        }
    }

    //删除节点的方法
    public void delete(int no) {
        //先判断该树的根节点是否为空
        if (root != null) {
            //判断该根节点是否和目标一致，如果一致则直接删除，置为空
            if (root.no == no) {
                root = null;
                //如果当前根节点不是要删除的节点，则需要递归删除
            } else {
                root.delete(no);
            }
            //如果为空则直接返回啦！
        } else {
            System.out.println("该树为空不能删除！");
            return;
        }
    }
}

class NodeND {
    public int no;
    public String name;
    public NodeND left;
    public NodeND right;

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

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

    /**
     * 1. 先判断是是不是空树，是空树则直接返回，
     * 2. 该树的root节点是不是要删除的节点，如果是root节点，则直接将整个树置为null
     * 3. 删除时先找到该要删除的节点的上一个节点，如果当前节点的左子节点是要删除的节点，则将this.left=null并且返回（结束递归删除）
     * 4. 如果当前节点的右子节点不为空，且就是要删除的节点则将this.right=null;并且返回（结束递归删除）
     * 5. 如果第3，4步没有删除节点，则将左子树进行递归删除
     * 6. 如果第5步也没有删除节点，则应当向右子树进行递归删除
     */
    public void delete(int no) {
        //* 3. 删除时先找到该要删除的节点的上一个节点，如果当前节点的左子节点是要删除的节点，则将this.left=null并且返回（结束递归删除）
        if (this.left != null && this.left.no == no) {
            this.left = null;
            return;
        }
        //4. 如果当前节点的右子节点不为空，且就是要删除的节点则将this.right=null;并且返回（结束递归删除）
        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 void pre() {
        //跟
        System.out.println(this);
        //左
        if (this.left != null) {
            this.left.pre();
        }
        //右
        if (this.right != null) {
            this.right.pre();
        }
    }

}

测试结果：

没删除4号节点之前的前序遍历：
Node1{no=1, name='吴吴'}
Node1{no=2, name='亦亦'}
Node1{no=3, name='凡凡'}
Node1{no=4, name='签签'}
Node1{no=5, name='word'}
Node1{no=6, name='very big'}
删除4号节点之后的前序遍历
Node1{no=1, name='吴吴'}
Node1{no=2, name='亦亦'}
Node1{no=3, name='凡凡'}

Process finished with exit code 0

复杂二叉树的删除

复杂二叉树的删除规定

规定：
如果删除的是叶子节点，则直接删除。
如果删除的是非叶子节点，则：

  1. 若非叶子节点的子节点只有一个，则将该子节点直接代替删除的节点
  2. 若非叶子结点的子节点有两个，则让左子节点代替原来删除的节点

复杂二叉树的删除思路

  1. 先判断是是不是空树，是空树则直接返回，
  2. 该树的root节点是不是要删除的节点，如果是root节点，则直接将整个树置为null
  3. 删除时先找到该要删除的节点的上一个节点，如果当前节点的左子节点是要删除的节点，则
    1. 先判断是否为叶子节点，如果是叶子节点，则将this.left=null并且返回（结束递归删除）
    2. 如果不是叶子节点，则有三种情况：
    a. 有右子节点没有左子节点：将删除的节点置为该节点的右子节点：结束递归
    b.有左子节点没有右子节点：将删除的节点置为该节点的左子节点：结束递归
    c.左右子节点都有 ：将删除的节点置为该节点的左子节节点：结束递归
  4. 如果当前节点的右子节点不为空，且就是要删除的节点则
    1. 先判断是否为叶子节点，如果是叶子节点，则将this.right=null并且返回（结束递归删除）
    2. 如果不是叶子节点，则有三种情况：
    a. 有右子节点没有左子节点：将删除的节点置为该节点的右子节点
    b.有左子节点没有右子节点：将删除的节点置为该节点的左子节点
    c.左右子节点都有 ：将删除的节点置为该节点的左子节节
  5. 如果第3，4步没有删除节点，则将左子树进行递归删除
  6. 如果第5步也没有删除节点，则应当向右子树进行递归删除

复杂删除的代码实现（以删除5号节点为例）

删除5号节点
主要的核心代码实现：

public void betterDelete(int no) {
        //1假设在左边找到了，先遍历左子节点，如果左边不为空，并且左边就是要删除的节点，则需要判断删除节点的左边是否为空
        if (this.left != null && this.left.no == no) {
            //1如果删除的就是叶子节点，即删除节点的左右都为空，则直接置空即可
            if (this.left.left == null && this.left.right == null) {
                this.left = null;
                return;
                //2如果删除的节点是非叶子节点，只有一个的情况,即左子节点为空，右子节点不为空
            } else if (this.left.left == null && this.left.right != null) {
                this.left = this.left.right;
                return;
                //剩下的情况是左子节点不为空右子节点为空和左右子节点都不为空，此时这两种情况都是将此删除节点的左子节点代替原来删除的节点
            } else {
                this.left = this.left.left;
                return;
            }
        }
        //如果左子树没有找到，假设找右子树找到了
        if (this.right != null && this.right.no == no) {
            //如果要删除的就是叶子节点，则将删除的节点直接置空
            if (this.right.left == null && this.right.right == null) {
                this.right = null;
                return;
                //如果删除的不是叶子节点，则有三种情况，第一种是左子节点没有，右子节点有
            } else if (this.right.left == null && this.right.right != null) {
                //将右子节点直接放到删除的位置
                this.right = this.right.right;
                return;
                //按照规则，剩下的都是把左子节点的值放到要删除的节点
            } else {
                this.right = this.right.left;
                return;
            }
        }
        //如果左节点和右节点都不是，则递归查找目标节点
        if (this.left != null) {
            this.left.betterDelete(no);
        }
        if (this.right != null) {
            this.right.betterDelete(no);
        }

    }

测试代码

package com.njupt.binaryTree;

/**
 * Creat with IntelliJ IDEA
 *
 * @Auther:倔强的加瓦
 * @Date:2021/07/23/11:16
 * @Description:
 */
public class SimpleDelete {
    public static void main(String[] args) {

        BinaryTr binary = new BinaryTr();
        NodeND node1 = new NodeND(1, "吴吴");
        NodeND node2 = new NodeND(2, "亦亦");
        NodeND node3 = new NodeND(3, "凡凡");
        NodeND node4 = new NodeND(4, "签签");
        NodeND node5 = new NodeND(5, "word");
        NodeND node6 = new NodeND(6, "very big");
        NodeND node7 = new NodeND(7, "55");
        NodeND node8 = new NodeND(8, "11");
        NodeND node9 = new NodeND(9, "烦烦");
        NodeND node10 = new NodeND(10, "签签");

        node1.left = node2;
        node1.right = node4;
        node2.left = node3;
        node4.left = node5;
        node4.right = node6;
        node5.left=node7;
        node5.right=node10;
        node7.left=node8;
        node7.right=node9;
        //给根节点赋值
        binary.root = node1;
        /*
        System.out.println("没删除4号节点之前的前序遍历：");
        binary.preSearch();
        binary.delete(4);
        System.out.println("利用简单删除4号节点之后的前序遍历");
        binary.preSearch();*/

        System.out.println("没删除5号节点之前的前序遍历：");
        binary.preSearch();
        binary.betterDelete(5);
        System.out.println("利用复杂规则删除5号节点之后的前序遍历");
        binary.preSearch();



    }
}

class BinaryTr {
    public NodeND root;

    //前序遍历的方法
    public void preSearch() {
        if (root == null) {
            System.out.println("当前树为空");
            return;
        } else {
            this.root.pre();
        }
    }

    //删除节点的方法
    public void delete(int no) {
        //先判断该树的根节点是否为空
        if (root != null) {
            //判断该根节点是否和目标一致，如果一致则直接删除，置为空
            if (root.no == no) {
                root = null;
                //如果当前根节点不是要删除的节点，则需要递归删除
            } else {
                root.delete(no);
            }
            //如果为空则直接返回啦！
        } else {
            System.out.println("该树为空不能删除！");
            return;
        }
    }
    //按照第二个规则删除的方法
    public void betterDelete(int no){
        //先判断该树的根节点是否为空
        if (root != null) {
            //判断该根节点是否和目标一致，如果一致则直接删除，置为空
            if (root.no == no) {
                root = null;
                //如果当前根节点不是要删除的节点，则需要递归删除
            } else {
                root.betterDelete(no);
            }
            //如果为空则直接返回啦！
        } else {
            System.out.println("该树为空不能删除！");
            return;
        }
    }
}

class NodeND {
    public int no;
    public String name;
    public NodeND left;
    public NodeND right;

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

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

    /**
     * 1. 先判断是是不是空树，是空树则直接返回，
     * 2. 该树的root节点是不是要删除的节点，如果是root节点，则直接将整个树置为null
     * 3. 删除时先找到该要删除的节点的上一个节点，如果当前节点的左子节点是要删除的节点，则将this.left=null并且返回（结束递归删除）
     * 4. 如果当前节点的右子节点不为空，且就是要删除的节点则将this.right=null;并且返回（结束递归删除）
     * 5. 如果第3，4步没有删除节点，则将左子树进行递归删除
     * 6. 如果第5步也没有删除节点，则应当向右子树进行递归删除
     */
    public void delete(int no) {
        //* 3. 删除时先找到该要删除的节点的上一个节点，如果当前节点的左子节点是要删除的节点，则将this.left=null并且返回（结束递归删除）
        if (this.left != null && this.left.no == no) {
            this.left = null;
            return;
        }
        //4. 如果当前节点的右子节点不为空，且就是要删除的节点则将this.right=null;并且返回（结束递归删除）
        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);
        }
    }
    /**
     * 规定：
     * 如果删除的是叶子节点，则直接删除。
     * 如果删除的是非叶子节点，则：
     * 1. 若非叶子节点的子节点只有一个，则将该子节点直接代替删除的节点
     * 2. 若非叶子结点的子节点有两个，则让左子节点代替原来删除的节点
     *
     * */
    public void betterDelete(int no) {
        //1假设在左边找到了，先遍历左子节点，如果左边不为空，并且左边就是要删除的节点，则需要判断删除节点的左边是否为空
        if (this.left != null && this.left.no == no) {
            //1如果删除的就是叶子节点，即删除节点的左右都为空，则直接置空即可
            if (this.left.left == null && this.left.right == null) {
                this.left = null;
                return;
                //2如果删除的节点是非叶子节点，只有一个的情况,即左子节点为空，右子节点不为空
            } else if (this.left.left == null && this.left.right != null) {
                this.left = this.left.right;
                return;
                //剩下的情况是左子节点不为空右子节点为空和左右子节点都不为空，此时这两种情况都是将此删除节点的左子节点代替原来删除的节点
            } else {
                this.left = this.left.left;
                return;
            }
        }
        //如果左子树没有找到，假设找右子树找到了
        if (this.right != null && this.right.no == no) {
            //如果要删除的就是叶子节点，则将删除的节点直接置空
            if (this.right.left == null && this.right.right == null) {
                this.right = null;
                return;
                //如果删除的不是叶子节点，则有三种情况，第一种是左子节点没有，右子节点有
            } else if (this.right.left == null && this.right.right != null) {
                //将右子节点直接放到删除的位置
                this.right = this.right.right;
                return;
                //按照规则，剩下的都是把左子节点的值放到要删除的节点
            } else {
                this.right = this.right.left;
                return;
            }
        }
        //如果左节点和右节点都不是，则递归查找目标节点
        if (this.left != null) {
            this.left.betterDelete(no);
        }
        if (this.right != null) {
            this.right.betterDelete(no);
        }

    }

    //前序遍历
    public void pre() {
        //跟
        System.out.println(this);
        //左
        if (this.left != null) {
            this.left.pre();
        }
        //右
        if (this.right != null) {
            this.right.pre();
        }
    }

}

测试结果：
在这里插入图片描述
从图中可以看出，按照规则删除5号节点和后，左边子节点7就代替了5号节点的位置。

没删除5号节点之前的前序遍历：
Node1{no=1, name='吴吴'}
Node1{no=2, name='亦亦'}
Node1{no=3, name='凡凡'}
Node1{no=4, name='签签'}
Node1{no=5, name='word'}
Node1{no=7, name='55'}
Node1{no=8, name='11'}
Node1{no=9, name='烦烦'}
Node1{no=10, name='签签'}
Node1{no=6, name='very big'}
利用复杂规则删除5号节点之后的前序遍历
Node1{no=1, name='吴吴'}
Node1{no=2, name='亦亦'}
Node1{no=3, name='凡凡'}
Node1{no=4, name='签签'}
Node1{no=7, name='55'}
Node1{no=8, name='11'}
Node1{no=9, name='烦烦'}
Node1{no=6, name='very big'}

Process finished with exit code 0
倔强的加瓦
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树~删除节点
qq_45058113的博客
04-14 2104
要求： 1）如果删除的是叶子节点，则删除叶子节点 2）如果删除的是非叶子节点，则删掉整个子树 3）测试，删掉3号和5号节点 思路： 首先考虑： 考虑如果树是空树，如果只有一个root节点，那么等价于将整个二叉树置空 然后进行下面操作 1）因为二叉树是单向的，所以我们是判断当前节点的子节点是否需要删除节点，而不能判断当前这个节点上是不是需要删除的节点 2）如果当前节点的左子节点不为空，且左子节点就是要删除的节点，就将this.left == null;并且返回（结束递归） 3) 如果当
删除二叉树的节点
开发者说
08-21 2万+
总体思想：分多种情况讨论 1.被删除节点没有子树的情况，直接删除，并修改对应父节点的指针为空。 2.对于只有一个子树的情况，考虑将其子树作为其父节点的子树，关于是左还是右，根据被删除的节点确定。 3.最复杂的是有两个子数的情况，可以考虑两种方法，都是同样的思想：用被删除节点A的左子树的最右节点或者A的右子树的最左节点作为替代A的节点，并修改相应的最左或最右节点的父节点的指针，修改方法类似2
二叉排序树的删除+图解
热门推荐
Frank---7的博客
03-30 5万+
图解 第一种情况 第二种情况 第三种情况 代码实现 package com.atguigu.binarysorttree; import com.sun.javafx.sg.prism.NGImageView; import javafx.scene.transform.Rotate; import java.io.InputStream; import java.util.Timer; /** * @创建人 wdl * @创建时间 2021/3/29 * @描述 */ public
删除二叉树节点
weixin_34365635的博客
03-08 98
function remove (root, key) { if (root == null){ return null; } var current = root; if (current.key > key) { current.left = remove(current.left); return current.le...
二叉树节点的删除
weixin_34061042的博客
09-25 825
昨天在看书的时候，突然看到二叉查找树的删除，以前学过，不过学的不仔细，结果研究了一晚上，才把二叉树的删除操作给整出来。 唉，以后看书要仔细啊。。。。。 先说一下如何删除二叉树查找树的节点吧。总共有三种情况 1.被删除的节点是叶子节点，这时候只要把这个节点删除，再把指向这个节点的父节点指针置为空就行 2.被删除的节点有左子树，或者有右子树，而且只有其中一个，那么只要把当前删除节点的父节点指向...
yezijiedian.rar_二叉树_叶子节点
最新发布
09-22
本文将深入探讨二叉树及其叶子节点的相关知识，并基于“yezijiedian.rar_二叉树_叶子节点”这个压缩包文件中的内容进行分析。 首先，二叉树是由节点构成的层次结构，每个节点最多有两个子节点，通常分为左子节点和...
数据结构（C语言版） 第五章 树与二叉树 知识梳理 + 作业习题详解1
08-04
3. 完全二叉树的叶子节点数n0与2度节点数n2的关系是n0 = n2 + 1。 完全二叉树是所有层都尽可能填满的二叉树，除了最后一层。若二叉树有5000个节点，那么根据性质3，其叶子节点的个数为2500。 二叉树的存储方式有两...
二叉树基础知识 包含ppt 和示例代码
08-19
示例代码通常会涵盖这些基本操作的实现，例如在Python中，你可以使用类来表示二叉树节点，然后实现插入、删除和查找的方法。在插入操作中，你需要比较新节点的值与当前节点的值，决定将其插入左子树还是右子树。删除...
Python探索之创建二叉树
09-21
### Python探索之创建二叉树 #### 知识点概览 1. **二叉树的概念** 2. **二叉树的基本属性** 3. **在Python中如何定义一个二叉树节点** 4. **如何使用Python创建二叉树结构** 5. **Python代码示例** #### 二叉树的...
二叉树的基础知识
05-20
- 插入和删除节点：根据二叉树的性质，可以设计出高效的插入和删除算法。 - 搜索：二叉搜索树允许快速查找特定值，左子树的所有节点值小于根节点，右子树所有节点值大于根节点。 - 文件系统：在文件系统中，目录...
java实现二叉树前序中序后序遍历查找以及删除节点
dongyu1703的博客
09-09 346
package course; public class BinaryTreeDemo { public static void main(String[] args) { // 先需要创建一颗二叉树 BinaryTree binaryTree = new BinaryTree(); // 创建需要的节点 HeroNodes root = new HeroNodes(1, "...
二叉树前中后序查找的实现
岁月平添了我的愁
09-13 115
思路分析 前序查找的思想 先判断当前节点的no是否等于要查找的 如果是相等，则返回当前节点 如果不等，则判断当前节点的左子节点是否为空，如果不为空，则递归左子节点前序查找 如果当前节点的左子树递归查找，找到节点就返回，否则继续判断，当前节点的右子节点是否为空，如果不为空，则右子树递归查找 中序查找思想 先判断当前节点的左子节点是否为空，如果不为空，则递归中序查找 如果找到，就返回，如果没有找到，就和当前节点比较，如果是则返回当前节点，否则继续进行右递归中序查找 如果右递归中序查找，找到就返回，
二叉树-删除节点（简单）
weixin_52725999的博客
08-09 786
13.1.2 二叉树-删除节点（简单） 要求： 如果删除的节点是叶子节点，则删除该节点 入关删除的节点是非子叶节点，则删除该子树 思路： 因为我们的二叉树是单向的，没办法找到前驱节点，所以我们判断当前节点的子节点是否需要删除，而不能去判断当前节点是不是需要删除的节点 先判断当前节点的左子节点不为空，并且左子节点就是要删除的节点，this.left = null,并且返回（结束删除工作） 如果当前节点的右子节点不为空，并且右子节点就是要删除的节点，this.right = null，并且返回（结束删除工
删除一个二叉树的子节点
DanEmpress的博客
09-10 3177
二叉查找树重要性质：   （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；     （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；      （3）左、右子树也分别为二叉排序树； 现有，如下一棵二叉查找树。                                                          
二叉树结点删除操作
weixin_37711738的博客
08-23 557
二叉树的结点删除要分为三类： 1、没有子结点 2、有一个子结点 3、有两个子结点 可以看一下这个
二叉树-删除节点
qq_30657195的博客
06-03 536
要求 如果删除的节点是叶子节点，则删除该节点。 如果删除的节点是非叶子节点，则删除树。 测试 删除5号叶子节点和3号树。 代码实现 package chapter18.binarytree object BinaryTreeDemo { def main(args: Array[String]): Unit = { //先使用比较简单的方法，直接关联 val root = new HeroNode(1, "宋江") val hero2 = new HeroNode(2,
数据结构笔记 —— 二叉树删除节点
一纸春秋的博客
12-20 2815
本篇博客是根据b站尚硅谷的数据结构教程，学习后写的学习笔记，本篇博客的重点在自己编写的代码注释和过程分析上 https://www.bilibili.com/video/BV1E4411H73v?p=99 规定： （1）如果删除的节点是叶子节点，则删除该节点 （2）如果删除的节点是非叶子节点，则删除该子树 思路： 首先先处理：考虑如果树是空树，或者只有一个root节点，则等价于将二叉树置空 然后考虑其他的情况 因为我们的二叉树是单向的，所以我们是判断当前节点的子节点是否是需要删除的节点，而不能判断当前的这
二叉树-节点删除
ytc958374686的博客
12-24 157
1、如果删除的节点是叶子节点，则删除该节点 2、如果删除的节点不是叶子节点，则删除该子树 public class BinaryTreeDemo { public static void main(String[] args) { //创建一颗二叉树 BinaryTree binaryTree = new BinaryTree(); //创...
二叉树右子节点插入操作实现
在给定的代码段中，涉及的知识点是关于二叉树的插入操作，具体是向右子树插入新的节点。这段代码是用C语言编写的，函数`InsertRightNode`用于将一个新数据`x`插入到二叉树中，已知的二叉树结点`curr`的右子树。以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值