二分搜索树（Binary Search Tree）2

最新推荐文章于 2024-08-24 17:09:16 发布
最新推荐文章于 2024-08-24 17:09:16 发布
阅读量506 收藏
点赞数 1
分类专栏： 数据结构 文章标签： java 后端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48019875/article/details/121499259
版权
本文详细介绍了如何在二分搜索树中删除最大元素、最小元素以及任意元素，包括不同情况下的处理策略，如节点为空、左节点不为空、右节点不为空以及左右节点都不为空的情况，并提供了完整代码实现。
摘要由CSDN通过智能技术生成

目录

1、删除二分搜索树的最大元素

（1）寻找二分搜索树的最大元素

 //先找到最大节点
        T maxNodeVal =findmaxnodeDG();
        if (maxNodeVal==null){
            System.out.println("isEmpty");
            return ;
        }

（2）返回以node为根的二分搜索树的最大值所在的节点

if (node.right==null){
            //进行删除操作
            Node leftNode =node.left;
            node.left =null;
            return  leftNode;
        }
        node.right =removeMaxNode(node.right);
        return node;

在这里插入图片描述

2、删除二分搜索树的最小元素

同理，

 //删除最小元素
    private void removeMixNode(){
        //先找到最小节点
        T minNodeVal =findminnodeDG();
        if (minNodeVal==null){
            System.out.println("isEmpty");
            return ;
        }
        System.out.println(minNodeVal.toString());
        //进行删除操作
        root= removeMixNode(root);
    }
    private Node removeMixNode(Node node) {
        if (node.left==null){
            //进行删除操作
            Node rightNode =node.right;
            node.right =null;
            return  rightNode;
        }
        node.left =removeMixNode(node.left);
        return node;
    }

在这里插入图片描述

1、删除二分搜索树的任意元素

（1）左右节点都为空

delNode=null；

在这里插入图片描述
（2）左节点不为空，右节点为空

leftNode =delNode.left;
delNode.left = null;
return leftNode;

在这里插入图片描述
（3）右节点不为空，左节点为空

rightNode =delNode.right;
delNode.right = null;
return rightNode;

在这里插入图片描述
（4）左右节点都不为空
//左右节点都不为空

 //1、找node 的后继(node.right中的最小节点)
            Node t = findminnodeDG(node.right);
            //2、node.right 中删除最小节点
            Node node1 = removeMixNode(node.right);
            //3、使用后继节点替换node
                t.left =node.left;
                t.right =node1;
            //4、生成新树，新树的根节点就是后继节点，返回新树根节点
            node.left=node.right=null;   //断开删除节点的左右节点 
            return t;

在这里插入图片描述

/删除任意节点
    public  T removeNode(T val){
        //判断根是否为0
        if (root==null){
            System.out.println("根为0");
            return null;
        }
        //不为零，则需要查找节点
        Node node=findNodeDG(root,val);
        if (node!=null){
            //删除节点
           root= removeNode(root,val);
           return node.val;
        }
        return  null;
    }

    /**
     * 从以root为根的二分搜索树中删除值为val的节点
     * @param node
     * @param val
     * @return
     */
    private  Node removeNode(Node node,T val){
        //递归到底的情况，找到了删除的节点
        //左节点为空，右节点为空，左右节点都为空
        if (node.val.compareTo(val)==0){
            if (node.left==null){
                Node rightNode =node.right;
                node.right =null;
                return  rightNode;
            }else if (node.right==null){
                Node leftNode =node.left;
                node.left =null;
                return leftNode;
            }else {
                //左右节点都不为空
                //1、找node 的后继(node.right中的最小节点)
                Node t = findminnodeDG(node.right);
                //2、node.right 中删除最小节点
                Node node1 = removeMixNode(node.right);
                //3、使用后继节点替换node
                    t.left =node.left;
                    t.right =node1;
                //4、生成新树，新树的根节点就是后继节点，返回新树根节点
                node.left=node1=null;
                return t;
            }
        }
        //递归操作
        if (node.val.compareTo(val)>0){
            node.left=removeNode(node.left,val);
        }else {
            node.right=removeNode(node.right,val);
        }
        return node;
    }
    //查找节点
    private Node findNodeDG(Node node, T val) {
        //最终没有找到节点，返回null
        if (node ==null){
            return  null;
        }
        if (node.val.compareTo(val)==0){
            return node;
        }else if (node.val.compareTo(val)>0){
            return findNodeDG(node.left,val);
        }else {
            return findNodeDG(node.right,val);
        }
    }

在这里插入图片描述

完整代码

package binary;

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class BinarySearch<T extends Comparable<T>> {
    public static void main(String[] args) {
        int[] arr = {28, 23, 15, 56, 34, 78};
        BinarySearch<Integer> bs = new BinarySearch<>();
        for (int i = 0; i < arr.length; i++) {
            bs.add(arr[i]);
        }
        System.out.println("是否包含15:" + (bs.contains(15) != null));
        System.out.println("是否包含100:" + (bs.contains(100) != null));

        System.out.println("--------中序遍历----------");
        List<Integer> l = bs.middleorder();
        l.stream().forEach(System.out::println);
        System.out.println("--------前序遍历----------");
        List<Integer> l1 = bs.preorder();
        l1.stream().forEach(System.out::println);
        System.out.println("--------后序遍历----------");
        List<Integer> l2 = bs.lastorder();
        l2.stream().forEach(System.out::println);
        System.out.println("--------层序遍历----------");
        List<Integer> l3 =bs.levelorder();
        l3.stream().forEach(System.out::println);
        System.out.println("-------查找最小元素--------");
        System.out.println(bs.findminnode());
        System.out.println("-------查找最大元素---------");
        System.out.println(bs.finfmaxnode());
        System.out.println("-------查找最小元素- 递归-------");
        System.out.println(bs.findminnodeDG());
        System.out.println("-------查找最大元素- 递归-------");
        System.out.println(bs.findmaxnodeDG());
/*        System.out.println("\n----------删除最小节点--------------");
        Integer val = bs.findminnodeDG();
        System.out.println(val != null ? val : "null");
        //删除最小元素
        bs.removeMixNode();
        //层序遍历
        l3.stream().forEach(item -> System.out.print(item + "   "));*/
/*        System.out.println("\n----------删除最大节点--------------");
        Integer val = bs.findmaxnodeDG();
        System.out.println(val != null ? val : "null");
        //删除最大元素
        bs.removeMaxNode();
        //层序遍历
        l3.stream().forEach(item -> System.out.print(item + "   "));*/
        System.out.println("---------------删除任意节点--------------");
        Integer integer = bs.removeNode(23);
        System.out.println(String.valueOf(integer));
        l3= bs.levelorder();
        l3.stream().forEach(item -> System.out.print(item + "   "));
    }

    class Node {
        T val;
        Node left;
        Node right;

        public Node(T val) {
            this.val = val;
        }

    }

    //定义根节点
    Node root;

    //构造方法
    public BinarySearch() {
        this.root = null;
    }

    //判断这棵树是否为空
    public boolean isEmpty() {
        return this.root == null;
    }


    //1、添加节点
    public void add(T ele) {
        //利用递归添加节点
        root = add(root, ele);
    }

    private Node add(Node root, T ele) {
        //如果根节点为空，创建一个新得二叉树，传ele参数进去
        if (root == null) {
            Node node = new Node(ele);
            return node;
        }
        //根节点不为空，将要添加的元素与跟的值进行比较大小
        //递归操作 不考虑等于的情况
        if (ele.compareTo(root.val) > 0) {
            root.right = add(root.right, ele);
        } else {
            root.left = add(root.left, ele);
        }
        return root;
    }

    //2、查询二叉树节点是否包含节点
    public Node contains(T ele) {

        return contains(root, ele);
    }

    private Node contains(Node root, T ele) {
        if (root == null) {
            return null;
        }
        //递归
        T val = root.val;
        if (ele.compareTo(val) == 0) {
            return root;
        } else if (ele.compareTo(val) > 0) {
            return contains(root.right, ele);
        } else {
            return contains(root.left, ele);
        }
    }

    //3、中序遍历 （按顺序）
    public List<T> middleorder() {
        List<T> list = new LinkedList<>();
        middleorder(root, list);
        return list;
    }

    private void middleorder(Node root, List<T> list) {
        //遍历到最后
        if (root == null) {
            return;
        }
        //左中右 遍历左边 返回根节点 遍历右边
        middleorder(root.left, list);
        list.add(root.val);
        middleorder(root.right, list);
        return;
    }

    //3、后序遍历
    public List<T> lastorder() {
        List<T> list = new LinkedList<>();
        lastorder(root, list);
        return list;
    }

    private void lastorder(Node root, List<T> list) {
        //遍历到最后
        if (root == null) {
            return;
        }
        //左右中 遍历左边 返回根节点 遍历右边
        middleorder(root.left, list);
        middleorder(root.right, list);
        list.add(root.val);
        return;
    }

    //3、前序遍历
    public List<T> preorder() {
        List<T> list = new LinkedList<>();
        preorder(root, list);
        return list;
    }

    private void preorder(Node root, List<T> list) {
        //遍历到最后
        if (root == null) {
            return;
        }
        //中左右 遍历左边 返回根节点 遍历右边
        list.add(root.val);
        middleorder(root.left, list);
        middleorder(root.right, list);
        return;
    }

    //4、层序遍历（广度优先)
    public List<T> levelorder() {
        List<T> lis = new LinkedList<>();
        if (root != null) {
            Queue<Node> queue = new LinkedList<>();
            queue.add(root);
            while (!queue.isEmpty()) {
                Node node = queue.poll();
                lis.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);//队列加入的方法
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return lis;
    }
    //5、查找最大最小元素
    public T findminnode(){
        if (root==null){
            return null;
        }
        Node curnode=root; //临时变量指向根节点
        while (curnode.left!=null){
            curnode=curnode.left;
        }
        return curnode.val;
    }
    public T finfmaxnode(){
        if (root==null){
            return null;
        }
        Node curnode=root;
        while (curnode.right!=null){
            curnode=curnode.right;
        }
        return curnode.val;
    }

    //5、查找最小元素 递归
    public T findminnodeDG(){
        if (root==null){
            return null;
        }
        return findminnodeDG(root).val;//从root节点开始查找最小元素

    }
    private Node findminnodeDG(Node root) {
        if (root.left==null){
            return root;
        }
        return findminnodeDG(root.left);//向左遍历
    }

    //查找最大元素 递归
    public T findmaxnodeDG(){
        if (root==null){
            return null;
        }
        return findmaxnodeDG(root);
    }

    private T findmaxnodeDG(Node root) {
        if (root.right==null){
            return root.val;
        }
        return findmaxnodeDG(root.right);
    }

    //删除最小元素
    private void removeMixNode(){
        //先找到最小节点
        T minNodeVal =findminnodeDG();
        if (minNodeVal==null){
            System.out.println("isEmpty");
            return ;
        }
        System.out.println(minNodeVal.toString());
        //进行删除操作
        root= removeMixNode(root);
    }
    private Node removeMixNode(Node node) {
        if (node.left==null){
            //进行删除操作
            Node rightNode =node.right;
            node.right =null;
            return  rightNode;
        }
        node.left =removeMixNode(node.left);
        return node;
    }
    //删除最大节点
    private void removeMaxNode(){
        //先找到最大节点
        T maxNodeVal =findmaxnodeDG();
        if (maxNodeVal==null){
            System.out.println("isEmpty");
            return ;
        }
        System.out.println(maxNodeVal.toString());
        //进行删除操作
        root= removeMaxNode(root);
    }
    private Node removeMaxNode(Node node) {
        if (node.right==null){
            //进行删除操作
            Node leftNode =node.left;
            node.left =null;
            return  leftNode;
        }
        node.right =removeMaxNode(node.right);
        return node;
    }

    //删除任意节点
    public  T removeNode(T val){
        //判断根是否为0
        if (root==null){
            System.out.println("根为0");
            return null;
        }
        //不为零，则需要查找节点
        Node node=findNodeDG(root,val);
        if (node!=null){
            //删除节点
           root= removeNode(root,val);
           return node.val;
        }
        return  null;
    }

    /**
     * 从以root为根的二分搜索树中删除值为val的节点
     * @param node
     * @param val
     * @return
     */
    private  Node removeNode(Node node,T val){
        //递归到底的情况，找到了删除的节点
        //左节点为空，右节点为空，左右节点都为空
        if (node.val.compareTo(val)==0){
            if (node.left==null){
                Node rightNode =node.right;
                node.right =null;
                return  rightNode;
            }else if (node.right==null){
                Node leftNode =node.left;
                node.left =null;
                return leftNode;
            }else {
                //左右节点都不为空
                //1、找node 的后继(node.right中的最小节点)
                Node t = findminnodeDG(node.right);
                //2、node.right 中删除最小节点
                Node node1 = removeMixNode(node.right);
                //3、使用后继节点替换node
                    t.left =node.left;
                    t.right =node1;
                //4、生成新树，新树的根节点就是后继节点，返回新树根节点
                node.left=node1=null;
                return t;
            }
        }
        //递归操作
        if (node.val.compareTo(val)>0){
            node.left=removeNode(node.left,val);
        }else {
            node.right=removeNode(node.right,val);
        }
        return node;
    }
    //查找节点
    private Node findNodeDG(Node node, T val) {
        //最终没有找到节点，返回null
        if (node ==null){
            return  null;
        }
        if (node.val.compareTo(val)==0){
            return node;
        }else if (node.val.compareTo(val)>0){
            return findNodeDG(node.left,val);
        }else {
            return findNodeDG(node.right,val);
        }
    }
}
高朵
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二分搜索树 Binary Search Tree
底层码农
11-06 6350
二分搜索树 Binary Search Tree
数据结构-二分搜索树(Binary Search Tree)
听雪楼
10-09 9278
特点 动态数据结构 是一颗二叉树 二分搜索树的每个节点的值: 每个节点的值都大于其左子树的所有节点的值 每个节点的值都小于其右子树的所有节点的值 每一颗子树也是二分搜索树 存储的元素必须有可比较性, Java中的话就要求二分搜索树保存的数据类型要实现Comparable接口, 或者使用额外的比较器实现 一般二分搜索树不包含重复元素, 当然也可以定义包含重复元素的二分...
C# 实现二分查找法 二分搜索树
什么风把您给吹来了
04-03 432
using System.Collections; using System.Collections.Generic; using System.Text; /// <summary> /// 二分搜索树 /// </summary> public class BST<T> where T : System.IComparable<T> { public class Node { public T data; ..
tree：唯一二叉搜索树2
qq_36333986的博客
05-12 60
Leetcode, UniqueBinarySearchTrees2 #include <iostream> #include <vector> #include <stack> using namespace std; struct TreeNode { int _val; TreeNode *_left; TreeNode *_right; TreeNode(int x) : _val(x), _left(nullptr), _right(nullptr)
Tree 二叉搜索树
......
04-11 85
每个节点最多两个子节点，其中左边节点的值小于该节点的值，右边节点的值大于该节点的值。为了简便起见，该二叉树装入的数据为整数，且不允许有重复的关键字值。 编程中为了简便，采用了递归算法，运算时会带来额外的开销，如果能将相应的算法替换为迭代，则更为有效。删除的算法相应复杂一些，但也可以承受。 API add：将数加入树 remove：从树中删除指定的节点 contains：树中是否包含指定的数 o...
数据结构-树（Tree）的介绍以及二分搜索树的实现
GGB__的博客
09-13 378
文章目录一、树是什么？二、二分搜索树二分搜索树的性质代码实现(重点：删除任意元素)二分搜索树实现集合SetSet接口实现类：二分搜索树实现集合映射Map 一、树是什么？ 这里引入百度百科的解释： 树是一种数据结构，它是由n(n≥1)个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 每个节点有零个或多个子节点；没有父节点的节点称为根节点；每一个非根节点有且只有一个父节点；除了根节点外，每个子节点可以分为多个不相交的子树。
二叉搜索树Binary Search Tree的构造、添加元素、删除元素
silverBlack
07-10 1190
一、概念 简单介绍一下BST的概念，可以将每个BST中的节点看成一个结构体，结构体中包含该节点的左右孩子以及该节点的key值。在BST中，每个节点都比它的左孩子要大（如存在的话）且比它的右孩子要小（若存在的话）。 由BST的概念可知，按照中序遍历的方式遍历一棵BST，一定会得到一个递增的有序序列。 在含有n个节点的BST中查询某个元素是否存在时，当这棵BST是一棵极度不平衡的二叉树，即每个节...
二分搜索树（Binary Search Tree）
小孙的博客
03-18 1810
本身是二叉树，只不过对于二分搜索树的每一个结点而言 大于其左子树的所有结点的值 小于其右子树的所有结点的值 同样，其子树也是一颗二分搜索树 那么该树中的元素要具有可比性不包含重复元素 ...
树形数据结构-二分搜索树Binary Search Tree
CSDN_LiMingfly的博客
05-04 558
B:如果当前树是有树根的，则对插入元素与当前树进行一个节点遍历操作，找到元素可以插入的索引位置 parent（挂到这个父节点下）。值查找的过程，就是对二叉搜索树的遍历，不断的循环节点，按照节点值的左右匹配，找出最终相当的值节点。最后是进行节点72与待删节点64的交换过程，更换三角关系，父节点、左子节点、右子节点。2：若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；待删除节点14，判断此节点的父节点的孩子节点，哪个等于14，找出左右。把待删节点的右孩子节点，挂到删除节点的右节点。
c++ 二分搜索树 二分查找树 binary search tree BST
11-24
二分搜索树（Binary Search Tree，简称BST）是计算机科学中一种非常重要的数据结构，它在处理有序数据时表现出高效性。在C++中，理解并掌握二分搜索树的概念、操作以及实现方法对于编程实践至关重要。二分搜索树的...
优化二分搜索树
02-09
“优化二分搜索树”通常指的是通过特定策略改进二叉搜索树的性能，使其在各种操作中达到最佳状态。在给定的项目中，我们可能会涉及以下几种优化方法： 1. **平衡二叉搜索树**：常见的平衡策略有AVL树和红黑树。AVL...
数据结构之利用PHP实现二分搜索树
12-16
数据结构中的二分搜索树（Binary Search Tree，BST）是一种特殊的二叉树，它具有以下特点： 1. 每个节点包含一个键（key）、一个关联的值、一个指向左子节点的引用和一个指向右子节点的引用。 2. 节点的键大于其左...
Java基于二分搜索树、链表的实现的集合Set复杂度分析实例详解
08-19
在Java编程语言中，集合框架提供了多种数据结构，如Set接口的实现，其中包括基于二分搜索树（Binary Search Tree, BST）和链表的数据结构。本篇将详细讲解这两种实现方式的集合Set在操作上的时间复杂度分析。 首先...
Binary Search Tree-开源
05-27
二叉搜索树（Binary Search Tree，简称BST），是一种特殊的二叉树数据结构，它的每个节点都包含一个键、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在这个C#库中，二叉搜索树被实现为一种高效的...
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 534
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 769
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
笔记redis
风止的博客
08-22 1046
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
最新发布
寂夜了无痕的博客
08-24 875
linux上datax 安装以及使用
二叉树(源码+lw+部署文档+讲解等)
lpw1012的博客
08-21 739
🌞博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注于Java、小程序技术领域和毕业项目实战，以及程序定制化开发、全栈讲解、就业辅导✌🌞👇🏻精彩专栏 推荐订阅👇🏻2023-2024年最值得选的微信小程序毕业设计选题大全：100个热门选题推荐✅2023-2024年最值得选的Java毕业设计选题大全：500个热门选题推荐✅Java精品实战案例《500套》
二分查找与二叉查找树解题指南
二叉查找树（Binary Search Tree，BST）是另一种数据结构，它具有以下性质： - 每个节点的左子树只包含比该节点小的节点。 - 每个节点的右子树只包含比该节点大的节点。 - 左右子树都是二叉查找树。 4. 二叉查找树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值