二叉排序树的增删改查（java版）

已于 2024-04-13 15:40:50 修改
阅读量557 收藏 3
点赞数 2
分类专栏： 数据结构与算法 文章标签： java 开发语言
于 2024-04-13 15:40:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51395608/article/details/137716449
版权

文章目录

最后的删除，目前我测试的是正确的

1. 基本节点

TreeNode:

class TreeNode{
    private int val;
    TreeNode left;
    TreeNode right;
    public void setLeft(TreeNode left){
        this.left = left;
    }
    public void setRight(TreeNode right){
        this.right = right;
    }
    TreeNode(){

    }
    TreeNode(int val){
        this.val = val;
    }
    public int getVal(){
        return this.val;
    }
    public String toStringNode(){
        String ans = "[ val = " + this.val;
        if(this.left != null){
            ans += "->left = " + this.left.toStringNode();
        }
        if(this.right != null){
            ans += "->right = " + this.right.toStringNode() + "]";
        }
        return ans;
    }
    public void setVal(int val){
        this.val = val;
    }
}

2. 二叉排序树

class BinaryTree{
    public TreeNode root;
}

里面写一些方法吧！！！

2.1 增加节点

其实就是插入：

public void insert(int val){
        TreeNode newNode = new TreeNode(val);
        if(root == null){
            root = newNode;
            return;
        }
        TreeNode curNode = root;
        TreeNode preNode;
        while(true){
            preNode = curNode;
            if(newNode.getVal() > curNode.getVal()){
                curNode = curNode.right;
                if(curNode == null){
                    preNode.setRight(newNode);
                    return;
                }
            }else{
                curNode = curNode.left;
                if(curNode == null){
                    preNode.setLeft(newNode);
                    return;
                }
            }
        }
    }

2.2 查找（就是遍历）就一起写了吧

跟修改一样

public void inOrder(TreeNode root){
        if(root == null)
            return;
        inOrder(root.left);
        System.out.print(root.getVal() + " ");
        inOrder(root.right);
    }
    public void preOrder(TreeNode root){
        if(root == null)
            return;
        System.out.print(root.getVal() + " ");
        preOrder(root.left);
        preOrder(root.right);
    }
    public void HOrder(TreeNode root){
        if(root == null)
            return;
        HOrder(root.left);
        HOrder(root.right);
        System.out.print(root.getVal() + " ");
    }

2.3 广度优先遍历

利用队列

// 广度优先搜索
    void BFS(){
        if(this.root == null){
            System.out.println("BFS: null");
            return;
        }
        System.out.print("BFS: ");
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(this.root);
        while(!queue.isEmpty()){
            TreeNode cur = queue.poll();
            System.out.print(cur.getVal() + " ");
            if(cur.left != null)
                queue.add(cur.left);
            if(cur.right != null)
                queue.add(cur.right);
        }
    }

2.4 删除（这个有点意思）

分了六类情况：

  • 目标节点是叶子节点（直接删了）
  • 目标节点只有一个孩子（直接连接上）
  • 目标节点有俩孩子
    • 左孩子没有右孩子（把目标右子树连在左孩子的右孩子上，然后目标父亲那条指向左孩子）
    • 右孩子没有左孩子（把目标左子树连在右孩子的左孩子上，然后目标父亲那条指向右孩子）
    • 最坏情况了，找目标节点的左孩子最右或者左孩子最左（交换值，删了那个被交换的孩子）
// 删除节点
    // 获取最左最右节点
    public TreeNode getLR(TreeNode root){
        if(root == null || (root.left == null && root.right == null))
            return null;
        TreeNode ans;
        if(root.left != null){
            if(root.left.right == null)
                return root.left;
            ans = root.left.right;
            while(ans.right != null){
                ans = ans.right;
            }
            // System.out.println("获取最右");
            return ans;
        }
        if(root.right != null){
            if(root.right.left == null)
                return root.right;
            ans = root.right.left;
            while(ans.left != null){
                ans = ans.left;
            }
            // System.out.println("获取最左");
            return ans;
        }
        return null;
    }
    // 获取父节点
    public TreeNode getParent(TreeNode root, int val){
        if(root == null || (root.left == null && root.right == null) || root.getVal() == val)
            return null;
        // 左孩子不等
        if(root.getVal() > val){
            if(root.left != null){
                if(root.left.getVal() == val)
                    return root;
                else
                    return getParent(root.left, val);
            }else
                return null;
        }else{
            if(root.right != null){
                if(root.right.getVal() == val)
                    return root;
                else
                    return getParent(root.right, val);
            }else
                return null;
        }
    }
    public void delNode(int val){
        TreeNode parent = new TreeNode(Integer.MAX_VALUE);
        parent.left = root;
        delNode(val, parent, null);
        this.root = parent.left;
    }
    public void delNode(int val, TreeNode root, TreeNode parent){
        if(root == null)
            return;
        if(root.getVal() < val){
            delNode(val, root.right, root);
        }else if(root.getVal() > val){
            delNode(val, root.left, root);
        }else{  // 相等
            if(root.left != null && root.right == null){    // 没有左孩子
                if(parent.left == root){
                    parent.left = root.left;
                }else{
                    parent.right = root.left;
                }
            }else if(root.left == null && root.right != null){  // 没有右孩子
                if(parent.left == root){
                    parent.left = root.right;
                }else{
                    parent.right = root.right;
                }
            }else if(root.left == null && root.right == null){  // 都是null
                if(parent.left == root){
                    parent.left = null;
                }else{
                    parent.right = null;
                } 
            }else{ // 进行交换
                if(root.left.right == null){
                    root.left.right = root.right;
                    if(parent.left == root){
                        parent.left = root.left;
                    }else{
                        parent.right = root.left;
                    }
                }else if(root.right.left == null){
                    root.right.left = root.left;
                    if(parent.left == root){
                        parent.left = root.left;
                    }else{
                        parent.right = root.left;
                    }
                }else{
                    TreeNode cur = getLR(root); // 获取最左最右节点
                // 删除那个节点
                TreeNode curParent = getParent(root, cur.getVal()); // 获取父节点
                if(curParent.getVal() > cur.getVal())
                    curParent.left = null;
                else{
                    curParent.right = null;
                }
                root.setVal(cur.getVal());  // 设置值
                }
            }
        }
    }

2.5 测试样例

public class Test2{
    public static void main(String[] args) {
        TreeNode node1 = new TreeNode(1);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(3);
        TreeNode node4 = new TreeNode(4);
        TreeNode node5 = new TreeNode(5);
        TreeNode node6 = new TreeNode(6);
        // 进行构建
        node1.setRight(node2);
        node1.setLeft(node3);
        node3.setLeft(node4);
        node4.setLeft(node5);
        node4.setRight(node6);
        // System.out.println(node1.toStringNode());
        BinaryTree b = new BinaryTree();
        b.insert(5);
        b.insert(7);
        b.insert(4);
        b.insert(2);
        b.insert(0);
        b.insert(3);
        b.insert(8);
        b.insert(6);
        b.insert(1);
        // System.out.println(b.root.toStringNode());
        // System.out.println(b.getParent(b.root, 3).getVal());
        for(int i = 8; i >= 0; i--){
            System.out.println("删除了：" + i);
            b.delNode(i);
            b.BFS();
            System.out.println();
        }
        
        // // 中序
        // System.out.println("中序：");
        // // 先序
        // System.out.println();
        // System.out.println("先序：");
        // b.preOrder(b.root);
        // // 后序
        // System.out.println();
        // System.out.println("后序：");
        // b.HOrder(b.root);
        // // 深度
        System.out.println();
        b.BFS();
    }
}
岳轩子
关注
专栏目录
[树节点] java实现增删改查以及节点的上下级新增
CO_Ye的博客
05-28 156
java逻辑查询获取父子节点，删除，新增复制等
数据结构之通过java实现二叉树的增删改查
weixin_44893467的博客
08-18 575
package tree; public class BinaryTree<Key extends Comparable<Key>, Value> { private int N; private Node root; private class Node { public Key K; public Value V; public Node left; public Node right;
二叉排序树增删改查
wdquan19851029的专栏
06-27 342
二叉排序树(BST--Binary Sort Tree)，要求任何一个非叶子节点，左子节点的值小于当前节点的值，右子节点的值大于当前节点的值。如果有相等的值，可以将其放在左子节点或者右子节点。 优点是既能快速查找，又能快速增删 其它数据结构的劣势： 数组（未排序）：查找速度慢（相对于二叉排序树） 数组（已排序）：可以使用二分查找、查找速度快，缺点：为了保证数组有序，在插入新数据，找到插入位置时，后面的数据需要整体迁移，速度慢。 链表：查找很慢，增删很快 package com.bruce....
java二叉排序树增删改查
0bug0warning的博客
10-03 910
二叉树的增加和查找 当你翻到这篇博客时，相信你对二叉树这种数据结构有一定的了解。通过二叉树对数据进行操作会比数组等数据结构优越的多。那么怎么对二叉树进行增删改查呢？ 首先来介绍下二叉树的插入、查询、遍历。 因为java面向对象，我们就把每个结点当作对象处理。 这个对象应该有value数值。指向左右孩子结点的对象，把整棵树连接起来。然后有一个指向自己的父结点，方便删除操作。 tree类定义： pub...
java 二叉树查询_java二叉排序树增删改查
weixin_42499790的博客
02-24 98
二叉树的增加和查找当你翻到这篇博客时，相信你对二叉树这种数据结构有一定的了解。通过二叉树对数据进行操作会比数组等数据结构优越的多。那么怎么对二叉树进行增删改查呢？首先来介绍下二叉树的插入、查询、遍历。因为java面向对象，我们就把每个结点当作对象处理。这个对象应该有value数值。指向左右孩子结点的对象，把整棵树连接起来。然后有一个指向自己的父结点，方便删除操作。tree类定义：public cl...
[Forest]＜二叉排序树＞增删查
qq_37039012的博客
04-23 579
二叉排序树 废话： 我又来做笔记了！这次是跟着《大话数据结构》巩固了一些树方面的知识，然后来做以下二叉排序树的笔记，之后打算把什么A树B树黑树白树都看一下（好像大话数据结构里没有讲红黑树，但红黑树挺有意思的），也估计会一节一节的做笔记，我不得不说，数据结构是一个很有意思的东西（虽然我到现在都没有搞懂图），当然配合算法就更有意思了。 毕竟现在的网络世界就是构建在一个又一个天才般的数据结构和算法的基础之上嘛。 好！废话不多说，开始讲二叉排序树。（基本照着大话数据结构念） 树的介绍 这里就不过多介绍了 树的排序
Python实现二叉搜索树增删改查
TaloyerG的博客
08-10 620
二叉搜索树，可以让你像搜索引擎一样快速地存储和检索数据。本文你将介绍二叉搜索树的基本概念和性质，以及如何用Python代码来实现它的基本操作和应用。
二叉排序树（二叉搜索树）BST增删改查操作
xinxin的博客
05-08 1129
二叉搜索树（Binary Search Tree，BST）是一种常用的二叉树数据结构，具有以下特点：1. **排序性质**：对于树中的每个节点，其左子树中的所有节点值都小于该节点的值，而右子树中的所有节点值都大于该节点的值。2. **唯一性质**：二叉搜索树中不存在相同值的节点。3. **递归性质**：二叉搜索树的左子树和右子树也分别是二叉搜索树。这些性质使得二叉搜索树成为一种非常高效的数据结构，可以支持快速的搜索、插入和删除操作。
二叉排序树的增删改查
zillll的博客
05-24 227
二叉排序树的增删改查 SqQue.c #include<stdio.h> #include<stdlib.h> #include "SqQue.h" /* 功能：初始化队列 参数：@maxl：最大长度 返回值：顺序队列的头指针 */ SqQue *InitSqQue(int maxl) { SqQue *q = malloc(sizeof(*q)); q->data = malloc(maxl * sizeof(element)); q->max_len
二叉排序树实现教师成果管理系统源码
01-09
系统的核心功能包括增、删、改、查四个部分： 1. **插入操作**：当新增一个教师成果时，系统会根据成果的关键信息（如发表论文的题目、时间等）创建一个新节点，并利用二叉排序树的插入规则，将新节点插入到合适的...
数据结构之二叉排序树的生成以及增删改查（Ｃ语言的实现）
any_ways的博客
06-02 4171
定义： 二叉排序树或是空树，或是满足如下性质的二叉树： １，若其左子树非空，则左子树上所有的结点的值均小于根结点的值； ２，若其右子树非空，则右子树上所有的结点的值均大于等于根结点的值； ３，其左右子树本身又各是一棵二叉排序树 例如： 这就是一棵二叉排序树，左子树小于根结点，右子树大于等于根结点，再比如下面： 这就不是一个二叉排序树了，因为左子树上面的４８大于根结点45 二叉排序树的特点： 中序遍历下面二叉排序树 得到的结果是：3　12　24　37　45　53　61　78　9
spring循环依赖解决方式
qq_36400213的博客
11-04 894
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
JAVA-01-变量
LJH_laura_li的博客
11-08 166
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 50
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
JAVA学习接口案例实例
最新发布
shangan_3的博客
11-08 123
【代码】JAVA学习接口案例实例。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 430
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 379
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
二叉链表作为二叉排序树的存储结构详解
对于静态查找表和动态查找表的区别，以及关键字和主次关键码的概念，都是本章内容的重要组成部分，有助于实现软件的功能要求，如交互式操作、增删改查和排序打印等。 第九章不仅教授了基础的数据结构概念，如线性表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值