二叉搜索树（二叉排序树）—Java

于 2023-02-11 13:57:54 发布
阅读量242 收藏 4
点赞数 5
分类专栏： 数据结构 文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74365243/article/details/128974091
版权

BinarySearchTree—二叉搜索树

🔎概念

二叉搜索树又称二叉排序树
可以是一棵空树
也可以不是一棵空树（doge）

在这里插入图片描述
上图所示就是一棵二叉搜索树
根节点root值为7，root的左子树的值全部比root的值小，root的右子树的值全部比root的值大
root.left–>root的左子树的根节点4，其左侧节点的值1比4小，右侧节点的值6比4大（但它们均小于7）
root.right–>root的右子树的根节点11，其左侧节点的值9比11小，右侧节点的值13比11大（但它们均大于7）

🔎模拟实现二叉树

🌻find–>查找二叉树中的元素

public TreeNode find(int val) {
        TreeNode cur = root;
        while(cur != null) {
            if(cur.val < val) {
                cur = cur.right;
            }else if(cur.val > val) {
                cur = cur.left;
            }else {//cur.val == val-->find!
                return cur;
            }
        }
        //未找到
        return null;
}

查找二叉搜索树中指定的val值
如果cur节点的值小于要查找的元素的值，cur = cur.right–>去树的右侧查找
在这里插入图片描述
如果cur节点的值大于要查找的元素的值，cur = cur.left–>去树的左侧查找
在这里插入图片描述

🌻insert–>在二叉树中插入元素

public void insert(int val) {
        if(root == null) {
            root = new TreeNode(val);
            return;
        }
        TreeNode pre = null;//叶子节点
        TreeNode cur = root;

        while(cur != null) {
            pre = cur;
            if(cur.val < val) {
                cur = cur.right;
            }else if(cur.val > val){
                cur = cur.left;
            }else {//二叉搜索树中不要插入相同的数据（无意义）
                return;
            }
        }
        if(val < pre.val) {
            pre.left = new TreeNode(val);
        }else {
            pre.right = new TreeNode(val);
        }
}

如果该搜索树是一棵空树，则插入的元素就是这棵树的root（根节点）
如果不是，在叶子节点的左/右侧插入对应的元素
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

🌻inorder–>中序遍历二叉树

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

🌻remove–>删除二叉树中的元素

cur–>要删除的节点 / pre–>要删除节点的父节点 / root–>根节点

  • 二叉搜索树的删除
  • cur.left == null–>要删除节点的左侧为空
    1)cur是根节点，root = cur.right
    2)cur不是根节点，cur是父节点的左,pre.left = cur.right
    3)cur不是根节点，cur是父节点的右,pre.right = cur.right
  • cur.right == null–>要删除节点的右侧为空
    1)cur是根节点，root = cur.left
    2)cur不是根节点，cur是父节点的左,pre.left = cur.left
    3)cur不是根节点，cur是父节点的右,pre.right = cur.left
  • cur.left != null && cur.right != null–>要删除节点的左右均不为空
    1)找cur左子树的右叶子节点–>左子树的最大值–>最大值的右节点一定为null
    2)找cur右子树的左叶子节点–>右子树的最小值–>最小值的左节点一定为null
    3)不可以是左子树的左叶子节点(左子树最小值) or 右子树的右叶子节点（右子树最大值）

🌼cur.left == null–>要删除节点的左侧为空

cur是根节点，root = cur.right
在这里插入图片描述
在这里插入图片描述
cur不是根节点，cur是pre节点的左,pre.left = cur.righ
在这里插入图片描述
在这里插入图片描述
cur不是根节点，cur是pre节点的右,pre.right = cur.right
在这里插入图片描述
在这里插入图片描述

🌼cur.right == null–>要删除节点的右侧为空

cur是根节点，root = cur.left
在这里插入图片描述
在这里插入图片描述
cur不是根节点，cur是pre节点的左,pre.left = cur.left
在这里插入图片描述
在这里插入图片描述
cur不是根节点，cur是pre节点的右,pre.right = cur.left
在这里插入图片描述
在这里插入图片描述

🌼cur.left != null && cur.right != null–>要删除节点的左右均不为空

找cur左子树的右叶子节点–>左子树的最大值–>最大值的右节点一定为null
在这里插入图片描述
找cur右子树的左叶子节点–>右子树的最小值–>最小值的左节点一定为null
在这里插入图片描述
不可以是左子树的左叶子节点(左子树最小值) or 右子树的右叶子节点（右子树最大值）
在这里插入图片描述

🌼代码演示

在这里插入图片描述

以cur的右子树的最小值举例

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

以cur的左子树的最大值举例
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

🌼完整remove代码

public void remove(int val) {
        TreeNode cur = root;
        TreeNode pre = null;
        while(cur != null) {
            if(cur.val == val) {//找到了值为val的节点
                removeNode(pre,cur);
                return;
            }
            else if(cur.val < val) {
                pre = cur;
                cur = cur.right;
            }else {//cur.val > val
                pre = cur;
                cur = cur.left;
            }
        }
}
//删除值为val的cur节点
private void removeNode(TreeNode pre,TreeNode cur) {
        if(cur.left == null) {
            if(cur == root) {
                root = cur.right;
            }else if(pre.left == cur){//cur在父节点左侧
                pre.left = cur.right;
            }else {//pre.right = cur --> //cur在父节点右侧
                pre.right = cur.right;
            }
        }else if(cur.right == null) {
            if(cur == root) {
                root = cur.left;
            }else if(pre.left == cur) {//cur在父节点左侧
                pre.left = cur.left;
            }else {//pre.right = cur --> //cur在父节点右侧
                pre.right = cur.left;
            }
        }else {//cur.left != null && cur.right != null
            TreeNode targetPre = cur;
            TreeNode target = cur.right;
            while(target.left != null) {//以cur的右子树的最小值举例-->右子树的左叶子节点
                //也可以是cur的左子树的最大值-->左子树的右叶子节点
                targetPre = target;
                target = target.left;
            }
            cur.val = target.val;
            //此时target的左侧一定为null-->target.left == null
            targetPre.left = target.right;//因为是寻找cur右子树的最小值
            //一定是target == targetPre.left
            //target == targetPre.right-->这种情况只会出现在寻找cur左子树的最大值
        }
}

🌻完整模拟代码

public class TestBinarySearch {
    static class TreeNode {
        public int val;
        public TreeNode left;
        public TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }
    }
    public TreeNode root = null;//根节点
    //查找二叉搜索树中指定的val值
    public TreeNode find(int val) {
        TreeNode cur = root;
        while(cur != null) {
            if(cur.val < val) {
                cur = cur.right;
            }else if(cur.val > val) {
                cur = cur.left;
            }else {//cur.val == val-->find!
                return cur;
            }
        }
        //未找到
        return null;
    }
    //插入元素
    public void insert(int val) {
        if(root == null) {
            root = new TreeNode(val);
            return;
        }
        TreeNode pre = null;
        TreeNode cur = root;

        while(cur != null) {
            pre = cur;
            if(cur.val < val) {
                cur = cur.right;
            }else if(cur.val > val){
                cur = cur.left;
            }else {//二叉搜索树中不要插入相同的数据（无意义）
                return;
            }
        }
        if(val < pre.val) {
            pre.left = new TreeNode(val);
        }else {
            pre.right = new TreeNode(val);
        }
    }
    //中序遍历
    public void inOrder(TreeNode root) {
        if(root == null) return;
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }
    //删除
    public void remove(int val) {
        TreeNode cur = root;
        TreeNode pre = null;
        while(cur != null) {//找到了值为val的节点
            if(cur.val == val) {
                removeNode(pre,cur);
                return;
            }
            else if(cur.val < val) {
                pre = cur;
                cur = cur.right;
            }else {//cur.val > val
                pre = cur;
                cur = cur.left;
            }
        }
    }
    //删除值为val的cur节点
    private void removeNode(TreeNode pre,TreeNode cur) {
        if(cur.left == null) {
            if(cur == root) {
                root = cur.right;
            }else if(pre.left == cur){//cur在父节点左侧
                pre.left = cur.right;
            }else {//pre.right = cur --> //cur在父节点右侧
                pre.right = cur.right;
            }
        }else if(cur.right == null) {
            if(cur == root) {
                root = cur.left;
            }else if(pre.left == cur) {//cur在父节点左侧
                pre.left = cur.left;
            }else {//pre.right = cur --> //cur在父节点右侧
                pre.right = cur.left;
            }
        }else {//cur.left != null && cur.right != null
            TreeNode targetPre = cur;
            TreeNode target = cur.right;
            while(target.left != null) {//以cur的右子树的最小值举例-->右子树的左叶子节点
                //也可以是cur的左子树的最大值-->左子树的右叶子节点
                targetPre = target;
                target = target.left;
            }
            cur.val = target.val;
            //此时target的左侧一定为null-->target.left == null
            targetPre.left = target.right;//因为是寻找cur右子树的最小值
            //一定是target == targetPre.left
            //target == targetPre.right-->只会出现在寻找cur左子树的最大值
        }
     }
}

🔎结尾

欢迎各位点赞留言，如果有不懂可以在评论区探讨或者私信，希望和大家一起进步

哔卟哔卟_: )
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
Java基于二叉查找树实现排序功能示例
08-29
Java基于二叉查找树实现排序功能示例 本文主要介绍了Java基于二叉查找树实现排序功能的示例，通过实例形式分析了Java二叉查找树的定义、遍历及排序等相关操作技巧。下面将对这些知识点进行详细的解释和分析。 一、...
Java二叉搜索树基础原理与实现方法详解
08-19
Java二叉搜索树基础原理与实现方法详解 本文详细介绍了Java二叉搜索树的基础原理与实现方法，涵盖了二叉树的定义、特点、二叉搜索树的定义、性质、思想、编程实现等方面的知识点。 一、树的定义 树是n（n>=0）个...
二叉排序树（Java实现）
qq_37837621的博客
04-30 2181
文章收藏的好句子：坚持和放纵是永远对立的矛盾，好习惯的坚持就像春天随手丢下的种子，经历漫长的仲夏，终将会迎来收获的金秋。而坏习惯的养成真的只能让人生的脚步停止在寒风凛冽的冬天，让你永远看不见下一个春天。目录1、数列的查询和添加问题2、二叉排序树 2、1二叉排序树的介绍 2、2二叉排序树的创建和遍历 2、3二叉排序树的删除1、数列的查询和添加...
Java数据结构——排序二叉树
m0_62969222的博客
05-25 835
排序二叉树概念 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。 对于二叉排序树的任何一个非叶子节点， 要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。 对二叉排序树进行中序遍历，结果就是按从小到大排序的。 排序二叉树类的定义 public class binarySortTree { class Node{ int value; Node left;
基本数据结构之二叉排序树（用Java语言实现）
qq_44182694的博客
01-30 1716
二叉排序树 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree）或二叉搜索树。二叉排序树为满足以下条件的树： ◎ 若左子树不空，则左子树上所有节点的值均小于它的根节点的值； ◎ 若右子树不空，则右子树上所有节点的值均大于或等于它的根节点的值； ◎ 左、右子树也分别为二叉排序树。如图4-10所示便是一个二叉排序树。 插入操作 在二叉排序树中进行插入操作时只需找到待插入的父节点，将数据插入即可，具体流程如下。 （1）将待插入的新节点与当前节点进行比较，如果两个
最优二叉搜索树问题（Java）
CSDN2022博客之星Top39；华为云博主7&，CSDN、稀土掘金、微信公众号、阿里云开发者社区、腾讯云社区、博客园、知乎、51CTO同名博主WHYBIGDATA；
11-23 1339
最优二叉搜索树问题（Java）
最优二叉搜索树算法 java实现
mrhanzhou5273的博客
06-29 1763
最优二叉搜索树 定义 数据集：S=[x1, x2, … , xn]S=[x_1, ~x_2,~\dots~, ~x_n]S=[x1​, x2​, … , xn​] 截图来自：北大公开课 算法设计与分析 最优二叉搜索树算法 ，下同 存取概率分布：P=[a0, b1, a1, b2, … , ai, bi+1, … , bn,&
Java实现二叉排序树
09-02
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉排序树中，对于...
tree-java.rar_tree_二叉搜索树
09-20
二叉搜索树（Binary Search Tree, BST）是一种特殊的二叉树数据结构，它具有以下特性： ...在实际应用中，二叉搜索树广泛用于数据库索引、文件系统、排序和搜索等问题，是数据结构和算法学习的基础部分。
java二叉查找树的实现代码
08-29
从这里我们可以看到，二叉查找树是一种搜索树，它能够快速地搜索、插入、删除树中的节点。 二、标签 标签中提到了java和二叉查找树，这两个词语是本文的关键词。java是一种编程语言，而二叉查找树是一种数据结构。...
二叉最优搜索树java实现
qq1076472549的博客
03-11 589
package com.bysj.common.算法.动态规划; /** * 二叉最优搜索树使用场景： * * 现在我有一张英文单词的文章，我要根据字典翻译为中文，所以我先要把字典构造成一个二叉最优搜索树，其中有的字搜索频率很高比如：草，爱，做等 * 所以我先给每个字定义一个频率q，这样每次搜索一个字的时候所需要的消耗就是pi*(depth{ki}+1){算法导论有论证};现在我们要构造一个遍...
【Java 数据结构】实现一个二叉搜索树
最新发布
程序猿教你打篮球的博客
01-09 6913
本期主要讲解： 1、认识二叉搜索树 2、实现一个二叉搜索树 2.1 成员变量 2.2 insert 方法 2.3 search 方法 2.4 remove 方法(重点) 3、二叉搜索树总结
【Java---数据结构】二叉搜索树
.很冷的博客
04-25 1757
一、认识二叉搜索树 二叉搜索树是一种特殊的二叉树，二叉搜索树又称二叉排序树。空树也是二叉搜索树。 二叉搜索树的特点： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 中序遍历二叉搜索树，得到是依次递增的序列。 二、实现二叉搜索树 ...
二叉排序树（Binary Sort Tree）查找、插入、删除 Java实现
CmdSmith的博客
03-30 2953
顺序存储的插入和删除可以通过在表末端插入和删除元素同最后一个元素互换来保持高效率，但是无序造成查找的效率很低。 如果查找的数据表是有序线性表，并且是顺序存储的，查找可以折半、插值、斐波那契等查找算法来实现，但是因为有序在插入和删除操作上，就需要耗费大量时间。 二叉排序树可以使得插入和删除的效率不错，又可以比较高效率地实现查找。 二叉排序树（Binary Sort Tree），又称为二
Java建立二叉排序树和平衡树
qq_30122883的博客
10-06 867
建立二叉排序树，是从前往后扫描数组，可以不保证高度最小，从头节点依次向下寻找要插入的适当位置。 建立平衡树，可以先将数组进行排序，然后选取中间元素作为根节点，数组中间元素左边的元素为根节点的左子树，数组中间右边的元素为根节点的右子树。 再对右子树和右子树选取中间节点，进行建树操作。 代码： package easy; import easy.JavaTree; import easy.TreeNo...
二叉排序(查找)树（Java实现）
qq_49306008的博客
12-02 948
二叉排序树：BST（Binary Sort（Search）Tree），又称为二叉查找树。其定义为：二叉排序树或者是一棵空树，或者是具有如下性质的二叉树。 ① 若它的左子树非空，则左子树上所有节点的值均小于根节点的值， ② 若它的右子树非空，则右子树上的所有节点的值均大于（或大于等于）根节点的值。 ③ 它的左右子树也分别为二叉排序树。 简单来说，对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。若有相同的值，可将该节点放在左子节点或右子节点。 二叉排序树的创建
Java——二叉搜索树（二叉排序树）的查找、插入、删除
char_m的博客
05-15 687
二叉搜索树概念查找插入删除 概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 1、若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 2、若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树 查找 插入 删除 ...
最优二叉搜索树的java实现
HusterClearLove
09-28 2063
问题来源： 我们在实现英语到汉语时，我们需要查询英语文本中的每一个单词所对用的汉语。我们此时可以构建一个二叉搜索树，将n个英语单词作为关键字，对应的汉语意思作为关联数据。也就时我们所理解key–value对。既然出现了二叉树，那么搜索二叉树的速度就成了我们需要关注的问题。主要问题就是，如果出现频率较低的英语单词放在根上，出现频率很高的英语单词出现在叶子节点，这样会使得我们每次的搜索都会很低效。问题
Java二叉查找树最简单实现
日积月累，天道酬勤
04-12 1068
什么是二叉树 简单来说，二叉树首先是一棵树，然后有以下条件 每个节点最多有2个孩子节点 二叉树有 一个根节点 一个左子树(可能为空) 一个右子树(可能为空) 特例 完全二叉树 叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树 满二叉树 一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树...
树形DP和单链表算法题目PPT课件——Java
12-15
本文将深入探讨树形动态规划和单链表算法，特别是如何判断一棵树是否为二叉搜索树（BST）以及如何对单链表进行快速排序（QuickSort）。 首先，我们来看树形动态规划。动态规划是一种将复杂问题分解为子问题并存储子...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值