二叉排序树的建立，删除，添加，遍历

最新推荐文章于 2026-06-17 10:40:45 发布
原创 最新推荐文章于 2026-06-17 10:40:45 发布 · 277 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java #算法 #数据结构
这篇博客介绍了如何使用Java实现二叉排序树（BST）的基本操作，包括插入、删除和中序遍历。代码展示了如何在BST中查找节点的父节点以及找到最小值节点来处理删除操作。通过示例展示了不同情况下删除节点的逻辑，包括节点无子节点、只有一个子节点和有两个子节点的情况。 
package com.jiahui.java;

/**7,3,10,12,5,1,9
 * @author shkstart
 * @create 2022-11-25 19:34
 */
public class Sort {
    public static void main(String args[]){
        SortBinaryTree tree=new SortBinaryTree(new Node(7));
        tree.add(new Node(3));
        Node node1=new Node(10);
        tree.add(node1);
        tree.add(new Node(12));
        tree.add(new Node(5));
        tree.add(new Node(1));
        tree.add(new Node(9));
        Node node=new Node(2);
        tree.add(node);
        tree.delete(node);
        tree.delete(node1);
        tree.inforOrder();
    }
}

class SortBinaryTree{
    Node root;

    public SortBinaryTree(Node root) {
        this.root = root;
    }

    public void inforOrder(){
        if (root==null){
            System.out.println("二叉排序树为空，无法遍历");
        }else {
            root.infoOrder();
        }
    }
    public void delete(Node node){
        if (root!=null){
            if (root==node){
                //左右都空
                if (root.getLeft()==null && root.getRight()==null){
                    root=null;
                    return;
                }
                //左右都不空
                if (root.getRight()!=null && root.getRight()!=null){
                    Node rightTree = root.getRight().getRight();
                    Node minNode = rightTree.minValue();
                    Node parentOfMin = root.searchParent(minNode);
                    if (parentOfMin.getLeft()!=null &&parentOfMin.getLeft()==minNode){
                        parentOfMin.setLeft(null);
                    }else {
                        parentOfMin.setRight(null);
                    }
                    root.setValue(minNode.getValue());
                    return;
                }
                //左空
                if (root.getLeft()!=null){
                    root=root.getLeft();
                    return;
                }
                //右空
                if (root.getRight()!=null){
                    root=root.getRight();
                    return;
                }

            }else {
                root.delete(node);
            }
        }else{
            System.out.println("二叉树为空，无法删除");
        }
    }
    public void add(Node node){
        if (root==null){
            root=node;
        }else {
            root.add(node);
        }
    }
}

class Node{
    private int value;
    private Node left;
    private Node right;

    public void setValue(int value) {
        this.value = value;
    }

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

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

    /**
     * 删除
     * @param node 要删除的节点
     */
    public void delete(Node node){
        int i=node.getValue();


        //左子树等于要找的node
        if (this.getLeft()!=null && this.getLeft().getValue()==i){
            //都为空
            if (this.getLeft().getLeft()==null && this.getLeft().getRight()==null){
              this.setLeft(null);
              return;
            }
            //都不为空
            if (this.getLeft().getLeft()!=null&&this.getLeft().getRight()!=null){
                Node rightTree = this.getLeft().getRight();
                Node minNode = rightTree.minValue();
//                Node parent = rightTree.searchParent(minNode);
//                if (parent.getLeft()==minNode){
//                    parent.delete();
//                }else {
//
//                }
                Node parentOfMin = this.searchParent(minNode);
                if (parentOfMin.getLeft()!=null &&parentOfMin.getLeft()==minNode){
                    parentOfMin.setLeft(null);
                }else {
                    parentOfMin.setRight(null);
                }
                this.getLeft().setValue(minNode.getValue());
                return;
            }
            //左不为空
            if (this.getLeft().getLeft()!=null ){
                this.setLeft(this.getLeft().getLeft());
                return;
            }
            //右不为空
            if (this.getLeft().getRight()!=null){
                this.setLeft(this.getLeft().getRight());
                return;
            }
        }

        //右子树等于
        if (this.getRight()!=null && this.getRight().getValue()==i){
            //都为空
            if (this.getRight().getLeft()==null && this.getRight().getRight()==null){
                this.setRight(null);
                return;
            }
            //都不为空
            if (this.getRight().getLeft()!=null && this.getRight().getRight()!=null){
                Node rightTree = this.getRight().getRight();
                Node minNode = rightTree.minValue();

                Node parentOfMin = this.searchParent(minNode);
                if (parentOfMin.getLeft()!=null &&parentOfMin.getLeft()==minNode){
                    parentOfMin.setLeft(null);
                }else {
                    parentOfMin.setRight(null);
                }
                this.getRight().setValue(minNode.getValue());
                return;
            }
            //左不为空
            if (this.getRight().getLeft()!=null ){
                this.setRight(this.getRight().getLeft());
                return;
            }
            //右不为空
            if (this.getRight().getRight()!=null){
                this.setRight(this.getRight().getRight());
                return;
            }
        }
        if (this.getLeft()!=null){
            this.getLeft().delete(node);
        }
        if (this.getRight()!=null){
            this.getRight().delete(node);
        }


    }
    public Node searchParent(Node temp){
        if (this.getLeft()==temp||this.getRight()==temp){
            return this;
        }
        if (this.getLeft()!=null && temp.getValue()<this.getValue()){
            return this.getLeft().searchParent(temp);
        }
        if (this.getRight()!=null && temp.getValue()>this.getValue()){
            return this.getRight().searchParent(temp);
        }
        return null;

    }
    public Node minValue(){
        Node node=this;
        while (node.getLeft()!=null){
            node=node.getLeft();
        }
        return node;

    }

    /**
     * 中序遍历
     */
    public void infoOrder(){
        if (this.getLeft()!=null){
            this.getLeft().infoOrder();
        }
        System.out.println(this);
        if (this.getRight()!=null){
            this.getRight().infoOrder();
        }
    }
    //添加
    public void add(Node node){
        if (node.getValue()>this.getValue()){
            if (this.getRight()==null){
                this.setRight(node);
            }else {
                this.getRight().add(node);
            }
        }
        if (node.getValue()<=this.getValue()){
            if (this.getLeft()==null){
                this.setLeft(node);
            }else {
                this.getLeft().add(node);
            }
        }
    }

    public Node(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public Node getLeft() {
        return left;
    }

    public Node getRight() {
        return right;
    }

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                '}';
    }
}

共勉！

数据结构之二叉排序树的生成以及增删改查（Ｃ语言的实现）
any_ways的博客
06-02 4315
定义： 二叉排序树或是空树，或是满足如下性质的二叉树： １，若其左子树非空，则左子树上所有的结点的值均小于根结点的值； ２，若其右子树非空，则右子树上所有的结点的值均大于等于根结点的值； ３，其左右子树本身又各是一棵二叉排序树 例如： 这就是一棵二叉排序树，左子树小于根结点，右子树大于等于根结点，再比如下面： 这就不是一个二叉排序树了，因为左子树上面的４８大于根结点45 二叉排序树的特点： 中序遍历下面二叉排序树 得到的结果是：3　12　24　37　45　53　61　78　9
二叉排序树创建、查找、插入、删除操作 《大话数据结构》 c++实现代码
m0_38047231的博客
10-31 1398
二叉排序树 二叉排序树也是一棵二叉树，所谓二叉树，就是“任何节点最多只允许两个子节点”，这两个子节点称为左右子节点。 //二叉排序树 #include&lt;iostream&gt; using namespace std; typedef int status; #define true 1 #define false 0 //二叉链表结点结构定义 typedef struct B...
二叉排序树的查找、插入、创建和删除
m0_51769031的博客
06-23 5055
二叉排序树的特性：1、若左子树非空，则左子树上所有结点的值均小于根节点的值；2、若右子树非空，则右子树上所有结点的值均大于根节点的值；3、左右子树又分别是一颗二叉排序树；综上，左子树结点的值......
二叉排序树的查找、插入、创建、结点删除python实现（大话数据结构版本）
lincoco49的博客
03-20 1413
定义结点 首先定义一个二叉链表结点结构的定义 class Node(object): """节点定义，包括数据项、左孩子、右孩子""" def __init__(self, data): self.data = data self.lchild = None self.rchild = None 查找 def search...
C语言数据结构二叉排序树的建立、插入、删除、查找操作（原理+完整代码）
m0_61440484的博客
01-14 2718
C语言数据结构二叉排序树的建立、插入、删除、查找操作（原理+完整可运行代码）
二叉排序树——BST（java）
weixin_41304904的博客
04-28 543
概念分析 二叉排序树：对于二叉排序树的任何一个非叶子节点，要求左子结点的值比当前结点的值要小，右子结点的值比当前结点的值要大。如果有相同的值，可以将该结点放在左子结点或者右子结点。 注：下文中所有BST均代表二叉排序树（BinarySortTree） 图解 我们将数组{7, 3, 10, 12, 5, 1, 9, 2}依次添加进BST中。 建立一个BST 叶子节点 class BinarySor...
二叉排序树的建立，查找，插入，删除，C++详解
2301_79431343的博客
12-08 2301
删除操作也按预期执行，当删除具有两个子节点的节点15时，算法选择了右子树中的最小节点来替代被删除的节点，确保了树的结构仍然满足二叉排序树的要求。而对于二叉排序树来说任何节点的键值一定大于其左子树中的每一个节点的键值，并小于其右子树中的每一个节点的键值。2如果要插入的数比当前结点大，就往当前结点的右子树走，否则就往当前结点的左子树走，直到末端，如果比末端的这个元素小，就成为它的左孩子，否则就成为它的右孩子。如果当前结点比要找的数小，就往当前结点的右子树找，否则就往当前结点的左子树找。
二叉排序树的添加、遍历、删除（看图写删除代码比较清晰）
大哥的叔的博客
08-17 1万+
package com.binarysortree; /** * @Auther: 大哥的叔 * @Date: 2019/8/17 06:15 * @Description: */ public class BinarySortTreeDemo { public static void main(String[] args) { int[] arr...
二叉排序树整理（创建，插入，查找，删除）
weixin_44267007的博客
09-03 9043
二叉排序树 查找表分为静态查找表和动态查找表，其中动态查找表的含义就是表结构本身是在查找过程中动态生成的。即若表中存在其关键字等于给定值keykeykey的记录，表明查找成功，否则插入关键字等于keykeykey的记录。 ​而动态查找表中最为典型的就是二叉排序树和哈希表，接下来重点对于二叉排序树的内容进行学习。 文章目录二叉排序树二叉排序树-定义二叉排序树-查找二叉排序树-插入二叉排序树-建立二叉排序树-遍历二叉排序树-删除二叉排序树-性能分析 二叉排序树-定义 ​ 空树或者是具有如下特性的二叉树被称为二叉
二叉排序树的创建,查询,删除,遍历和插入（C++类实现）
jyx1572676601的博客
02-09 1177
视频教程推荐：懒猫老师-数据结构-(58)二叉排序树的删除(二叉查找树)_哔哩哔哩_bilibili 直接上代码，有简单注释。 #include<iostream> #include<array> #define DataType int using namespace std; struct BST_node { DataType data; BST_node *left; BST_node *right; }; class BST { private: BST_n
二叉排序树的建立，插入，删除，查找，以及遍历
qq_42317725的博客
09-25 455
C++和数据结构的新手试炼，删除函数写的非常冗杂，望大神多多指教~ #include "BiTree.h" //访问函数 void visit(BiTree T) { cout << T->data << " "; return; } //递归中序遍历 void InOrder(BiTree T) { if (T) { InOrder(T->lchild); visit(T); InOrder(...
二叉树遍历、插入、删除等常见操作
热门推荐
Sunshine的专栏
12-03 1万+
1.二叉查找树的创建 2.二叉查找树清空 3.二叉查找树查询 4.查找最大值、最小值 5.二叉查找树插入操作 6.二叉查找树的删除操作 7.分别使用非递归和递归方式（部分用多种方式）实现树的先序遍历、中序遍历和后序遍历
二叉树的基本操作（创建 三种遍历 搜索 删除）
fatherofli的博客
06-05 274
树是一种具有多个节点的数据结构，它的特点是根朝上，叶朝下。它的每个节点有零个或多个子节点；没有父节点的节点称为根节点；每一个非根节点有且只有一个父节点；除了根节点外，每个子节点可以分为多个不相交的子树。二叉树也是树的一种，他的特点是每个根节点最多只能有两个子节点，也就是0，1，2种节点 二叉树初始化： 二叉树的插入： 二叉树的创建： 二叉树的遍历： 前序遍历 中序遍历 后序遍历 前序遍历： 根节点->左子树->右子树 中序遍历： 左子树->根节点->右子树 后序遍历： 左子树->右子
二叉树的增删以及遍历（java）
Pluto372的博客
06-24 353
简介 二叉树的相关概念，如，树高度，节点层数，节点度数，路径，叶节点，分支节点，根节点，父节点，左节点，右节点，兄弟节点，祖先节点，子孙节点，左子树，右子树等基本概念，不再赘述。 本文主要讲解二叉树的创建，删除，以及四种遍历方式。 二叉树 二叉树是一个递归的数据结构，每个节点最多有两个子节点。 通常二叉树是二分查找树，每个节点它的值大于或者等于在它左子树节点上的值，小于或者等于在它右子树节点上的值，如下图 二叉树的遍历方式有4种： 前序遍历：root -> left -> right 中序遍
二叉搜索树的创建、插入、遍历、删除
julia_xueli的博客
11-26 1486
二叉搜索树 本文主要记录自己完成学校课程布置的有关“二叉搜索树”的代码闯关题的代码和思路心得，部分内容有借鉴身边大佬，借鉴部分会有标注。 二叉搜索树的结构体定义 struct node { int data ; struct node *lchild ,*rchild ; }; typedef struct node *pTree; 创建 插入结点 以及三种遍历方式 /*1.创建一个二叉树结点,值为element*/ pTree createTreeNode(int e
【数据结构与算法】二叉树的创建，插入，遍历，删除，删除节点实现
码农code之路
07-10 5771
二叉树是每个结点最多有两个子树的树结构。使用广泛，使用C来实现对二叉树的操作。 示例：代码实现构造如下二叉树 #include <iostream> using namespace std; typedef struct BinaryTree { int data; struct BinaryTree* lchild; struct BinaryTree* rch...
基于java Web 训练管理系统设计与实现 源码 论文
最新发布
qq_251836457的博客
06-17 1536
用户信息实体，主要包括 用户编号,用户名,密码,姓名,性别,出生日期,证件号,民族,政治面貌,单位,入伍时间,照片,班级,排 等信息实体。1 用户( 用户编号,用户名,密码,姓名,性别,出生日期,证件号,民族,政治面貌,单位,入伍时间,照片,班级,排 )讨论信息实体，主要包括 讨论编号,疑问,说明,发布人,发布时间,状态,回答 等信息实体。系统主要用户实体,班级实体,排实体,科目实体,成绩实体,教学视频实体,教学理论实体,讨论实体，如图所示。班级信息实体，主要包括 班级编号,班级 等信息实体。
24-Django请求全链路-WSGI到数据库响应的完整旅程
weixin_44081096的博客
06-15 1176
你点了浏览器的"刷新"按钮，0.5 秒后页面渲染完毕。这 0.5 秒里发生了什么？本文把 Django 处理一个 HTTP 请求的完整链路拆为六个步骤：WSGI Server 接收 TCP 连接 → 中间件栈的洋葱模型逐层处理 → URL 路由匹配 → View 执行业务逻辑 → ORM 生成 SQL 并发送到数据库 → Template 渲染或 JSON 序列化返回响应。每一步都配有对应的源码位置和关键代码片段，读完你能对一个请求的全生命周期建立起清晰的空间模型。穿插真实调试经历——一个中间件错误导致所有
SAP-ABAP：SAP表与视图权限管控方案：表维护权限、视图访问权限配置实操
baidu_35680696的博客
06-15 733
SAP表与视图权限管控方案摘要 本文详细介绍了SAP系统中表和视图的三层级权限管控方案： 表维护生成器权限：通过配置权限组实现基础访问控制，支持自定义权限对象（SU21）进行细粒度管控 SM30事务码权限：利用权限对象S_TABU_DIS控制表维护操作，可在PFCG中配置角色实现权限细分 CDS视图DCL权限：通过访问控制定义实现记录级权限过滤，支持基于权限对象的动态数据访问控制 文章提供了完整的配置流程和ABAP代码示例，涵盖权限组创建、DCL语法、权限校验等关键操作，帮助企业构建安全的数据访问体系，满足
自己动手写一个spring之IOC_3
wang0907的博客
06-15 745
本文来继续增加IOC部分的功能，增加基于@Autowired注解注入bean的功能。。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值