二叉排序树

最新推荐文章于 2022-12-01 16:57:00 发布
最新推荐文章于 2022-12-01 16:57:00 发布
阅读量353 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45301190/article/details/102024811
版权

二叉排序树的优点：
二叉排序树相较于数组，不仅查询快，而且增删速度也更快；

二叉排序树的创建代码实现：

public class BinarySortTreeDemo {
    public static void main(String[] args) {
        int[] arr = {7, 3, 10, 12, 5, 1, 9};
        BinarySortTree tree = new BinarySortTree();

        //循环添加结点到二叉排序树
        for (int i = 0; i < arr.length; i++) {
            tree.add(new Node(arr[i]));
        }

        System.out.println("中序遍历二叉排序树:");
        tree.infixOrder();
    }
}

class BinarySortTree{
    private Node root;

    //创建二叉树的方法
    public void add(Node node){
        if(root == null){
            root = node;
        }else {
            root.add(node);
        }
    }

    //遍历的方法,中序遍历
    public void infixOrder(){
        if (root != null){
            root.infixOrder();
        }else {
            System.out.println("当前二叉树为空!");
        }
    }
}

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

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

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

    //递归的方法添加节点,需要满足二叉排序树的要求
    public void add(Node node){
        if (node == null){
            return;
        }
        //判断结点和当前结点的大小关系
        if (node.value < this.value){
            //如果当前左子结点为空
            if (this.left == null){
                this.left = node;
            }else {
                //递归向左子树添加
                this.left.add(node);
            }
        }else {
            //如果当前右子结点为空
            if (this.right == null){
                this.right = node;
            }else {
                this.right.add(node);
            }
        }
    }
    //中序遍历
    public void infixOrder(){
        if (this.left != null){
            this.left.infixOrder();
        }
        System.out.println(this);
        if (this.right != null){
            this.right.infixOrder();
        }
    }
}

二叉排序树的删除：

以此棵二叉树为例：
要删除的二叉树安案例

第一种情况: 删除叶子节点(比如: 2,5, 9, 12)思路

(1)需求先去找到要删除的结点targetNode
(2)找到targetNode的父结点parent
(3)确定targetNode是parent的左子结点还是右子结点
(4)根据前面的情况来对应删除左子结点parent.left = null右子结点parent.right = null;

第二种情况: 删除只有- -颗子树的节点比如1思路

(1)需求先去找到要删除的结点targetNode
(2)找到targetNode的父结点parent
(3)确定targetNode的子结点是左子结点还是右子结点
(4) targetNode是parent的左子结点还是右子结点
(5)如果targetNode有左子结点

5.1如果targetNode是parent的左子结点 parent.left = targetNode.left;
5.2如果targetNode是parent的右子结点 parent.right = targetNode.left;

(6)如果targetNode有右子结点
6.1如果targetNode是parent的左子结点 parent.left = targetNode.right
6.2如果targetNode是parent的右子结点 parent.right = targetNode.right

情况三: 删除有两颗子树的节点. (此如: 7,3, 10)思路

(1)需求先去找到要删除的结点targetNode
(2)找到targetNode的父结点parent
(3)从targetNode 的右子树找到最小的结点
(4)用一一个临时变量，将最小结点的值保存temp = min
(5)删除该最小结点
(6) targetNode.value = temp


package BinarySortTree;

public class BinarySortTreeDemo {
    public static void main(String[] args) {
        int[] arr = {7, 3, 10, 12, 5, 1, 9 , 0};
        BinarySortTree tree = new BinarySortTree();

        //循环添加结点到二叉排序树
        for (int i = 0; i < arr.length; i++) {
            tree.add(new Node(arr[i]));
        }

        System.out.println("中序遍历二叉排序树:");
        tree.infixOrder();

        tree.delete(10);

        System.out.println("中序遍历二叉排序树:");
        tree.infixOrder();
    }
}

class BinarySortTree{
    private Node root;

    //创建二叉树的方法
    public void add(Node node){
        if(root == null){
            root = node;
        }else {
            root.add(node);
        }
    }

    //遍历的方法,中序遍历
    public void infixOrder(){
        if (root != null){
            root.infixOrder();
        }else {
            System.out.println("当前二叉树为空!");
        }
    }

    //查找要删除的结点
    public Node search(int value){
        if (root != null){
            return root.search(value);
        }else {
            return null;
        }
    }

    //查找要删除的结点的父结点
    public Node searchParent(int value){
        if (root != null){
            return root.searchParent(value);
        }else {
            return null;
        }
    }

    //编写方法
    /**
     * 1.返回以node为根结点的二叉排序树的最小节点值
     * 2.删除node为根结点的二叉排序树的最小结点
     * @param node
     * @return
     * */
    public int delRightTreeMin(Node node){
        Node target = node;
        while (target.left != null){
            target = target.left;
        }
        delete(target.value);
        return target.value;
    }

    //删除结点
    public void delete(int value){
        if (root == null){
            return;
        }else {
            //先找到要删除的结点
            Node targetNode = search(value);
            //如果没有找到要删除的结点
            if (targetNode == null){
                return;
            }
            //如果我们发现这颗二叉树只有一个节点
            if (root.left == null && root.right == null){
                root = null;
                return;
            }

            //去找到targetNode的父结点
            Node parent = searchParent(value);
            //如果要删除的结点是叶子结点
            if (targetNode.left == null && targetNode.right == null){
                //判断targetNode是parent的左子结点还是右子结点
                if (parent.left != null && parent.left.value == value){//左子节点
                    parent.left = null;
                }else if (parent.right != null && parent.right.value == value){
                    parent.right = null;
                }
            }else if (targetNode.left != null && targetNode.right != null){//删除两个子树的结点
                int minVal = delRightTreeMin(targetNode.right);
                targetNode.value = minVal;
            }else {//删除一个子树的结点
                //如果要删除的树有左子节点
                if (targetNode.left != null){
                    if (parent != null) {
                        //如果targetNode有左子结点
                        if (parent.left.value == value) {
                            parent.left = targetNode.left;
                        } else {
                            parent.right = targetNode.left;
                        }
                    } else {
                        root = targetNode.left;
                    }
                }else {
                    if (parent != null) {
                        //如果targetNode有右子结点
                        if (parent.left.value == value) {
                            parent.left = targetNode.right;
                        } else {
                            parent.right = targetNode.right;
                        }
                    }else {
                        root = targetNode.right;
                    }
                }
            }

        }
    }

}

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

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

    //查找结点
    /**
     * @param value 希望删除的结点的值
     * @return 查找到节点就返回该节点，没有找到就返回null
     * */
    public Node search(int value){
        if (value == this.value){
            return this;
        }else if (value < this.value){
            if (this.left == null){
                return null;
            }
            return this.left.search(value);
        }else {
            if (this.right == null){
                return null;
            }
            return this.right.search(value);
        }
    }

    //查找要删除结点的父结点
    /**
     * @param value  要找到的结点的值
     * @return  返回的是要删除的结点的父结点，如果没有就返回null
     * */
    public Node searchParent(int value){
        //如果当前结点就是要删除的结点的父结点,就返回
        if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)){
            return this;
        }else {
            //如果查找的值小于当前结点的值，并且当前结点的左子结点不为空
            if (value < this.value && this.left != null){
                return this.left.searchParent(value);
            }else if (value >= this.value && this.right != null){
                return this.right.searchParent(value);
            }else {
                return null;  //没有找到父结点
            }
        }
    }

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

    //递归的方法添加节点,需要满足二叉排序树的要求
    public void add(Node node){
        if (node == null){
            return;
        }
        //判断结点和当前结点的大小关系
        if (node.value < this.value){
            //如果当前左子结点为空
            if (this.left == null){
                this.left = node;
            }else {
                //递归向左子树添加
                this.left.add(node);
            }
        }else {
            //如果当前右子结点为空
            if (this.right == null){
                this.right = node;
            }else {
                this.right.add(node);
            }
        }
    }
    //中序遍历
    public void infixOrder(){
        if (this.left != null){
            this.left.infixOrder();
        }
        System.out.println(this);
        if (this.right != null){
            this.right.infixOrder();
        }
    }
}
xiuzhiwu
关注
二叉查找树特性,优点,缺点
Strangerrainyday的博客
09-01 8156
概述: 二叉排序树（Binary Sort Tree）,又称二叉查找树（Binary Search Tree）,亦称二叉搜索树.是数据结构中的一类.在一般情况下,查询效率比链表结构要高. 定义: 一棵二叉查找树是一棵二叉树,每个节点都含有一个Comparable的键（以及对应的值）. 每个节点的键都大于左子树中任意节点的键而小于右子树中任意节点的键. 每个节点都有两个链接,左链接、右链接，分别指向自己的左子节点和右子节点，链接也可以指向null. 尽管链接指向的是节点,可以将每个链接看做指向了另一棵二
二叉排序树总结
liu_shijia的博客
05-21 1007
对于二叉排序树并不难于理解，它和中序遍历完美契合，应用起来感觉很舒服。做的这两道题目，第一个就是二叉排序树的基本操作插入。二叉排序树的插入操作比较简单，但是它的删除操作比较复杂，需要好好掌握。通过这两个题目，可以看出来递归思想的重要性，用它来解决题目方便简洁。还有我们后面学的平衡二叉树，虽然自己代码写不出来，但是理解的还可以，平衡二叉树的调整还是很有意思。现在对程序语言的兴趣挺浓厚，要加强学习。
二叉树的特点
zhushixia1989的博客
11-03 2688
【数据结构】之二叉排序树的实现（C语言）
xiangjunyes的博客
10-01 1060
文章目录二叉排序树二叉排序树的查找操作二叉排序树的插入操作二叉排序树的删除操作总结 如果我们要查找的数据集是有序线性表，并且是顺序存储的，查找可以用折半，插值，等查找算法来实现。可惜，因为有序，在插入和删除操作上，就需要耗费大量的时间。 有没有一种既可以使得插入和删除的效率不错，又可以比较高效率的实现查找的算法呢？ 二叉排序树 二叉排序树，又称为二叉查找树。它或者是一颗空树，或者是具有下列性质的二叉树。 若他的左子树不为空，则左子树上所有结点的值均小于他的根节点的值。 若他的右子树不为空，则右子树上所有结
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
二叉排序树，又称二叉查找树或二叉搜索树，是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种性质使得...
实现二叉排序树的各种算法
07-25
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在处理搜索、插入和删除操作时具有较高的效率。二叉排序树的主要特性是：对于任意节点，其左子树中的所有...
二叉排序树的实现与基本操作
08-31
二叉排序树（Binary Sort Tree，BST），又称为二叉查找树，是一种特殊的二叉树数据结构，其每个节点都遵循以下三个关键性质： 1. 左子树上的所有节点的值都小于当前节点的值。 2. 右子树上的所有节点的值都大于当前...
数据结构_各种二叉树的优劣（衍生原因）
赵星海的博客
07-27 1625
原文：https://blog.csdn.net/z702143700/article/details/49079107 1. 二叉查找树 (Binary Search Tree) 概念 二叉查找树又称二叉搜索树，二叉排序树，特点如下: 1. 左子树上所有结点值均小于根结点 2. 右子树上所有结点值均大于根结点 3. 结点的左右子树本身又是一颗二叉查找树 4. 二叉查找树中序遍历得到结果是递增排序的结点序列。 BST 的操作代价分析： (1) 查找代价： 任何一个数据的查找过程都需要从根...
二叉排序树（BST）优秀树结构的基石
doomwatcher的博客
03-23 711
📣 📣 📣 📢📢📢 ☀️☀️你好啊！小伙伴，我是小冷。是一个兴趣驱动自学练习两年半的的Java工程师。 📒 一位十分喜欢将知识分享出来的Java博主⭐️⭐️⭐️，擅长使用Java技术开发web项目和工具 📒 文章内容丰富：覆盖大部分java必学技术栈，前端，计算机基础，容器等方面的文章 📒 如果你也对Java感兴趣，关注小冷吧，一起探索Java技术的生态与进步，一起讨论Java技术的使用与学习 ✏️高质量技术专栏专栏链接: 微服务，数据结构，netty，单点登录，SSM ，SpringCloudAli.
二叉排序树相对哈希表的优点 Advantages of Binary Search Tree over Hash Table
wengyupeng 蜗牛一步一步向前。。。
12-17 480
1.  Binary Search Trees (reference-based) are memory-efficient. They do not reserve more memory than they need to.      For instance, if a hash function has a range R(h) = 0...100, then you need to a...
二叉树，平衡二叉树，B树，B+树，红黑树
最新发布
Bug制造者
12-01 1071
二叉树，平衡二叉树，B树，B+树，红黑树
二叉排序树相关知识详解
hi_siri的博客
11-21 578
二叉排序树（BST树） 二叉树。 二叉排序树或是一棵空树，或具有以下特性： 1.若左子树非空，其左子树上所有结点的值均小于根节点的值； 2.若右子树非空，其右子树上所有结点的值均大于根节点的值； 3.左右子树也满足二叉排序树的特性； 4.左子树结点值<根节点值<右子树结点值，所以如果对二叉排序树进行中序0遍历可以得到一个递增的有序序列。 ...
树与二叉树与二叉平衡排序树(下)
乌龙茶不是可燃的嘛的博客
07-25 418
二叉排序树 什么是二叉排序树？ 对于任意一个节点，左边比自己小，右边比自己大的树就叫做二叉排序树 让我们用代码构建一个二叉排序树 private static int count = 0; public static TreeNode addMapNode(TreeNode root,TreeNode newNode){ if (root == null)return newNode; if (root.val == newNode.val)return root;
二叉搜索树（二叉排序树）
smithdoudou88的专栏
09-25 1965
当用线性表作为表的组织形式时，可以有三种查找法。其中以二分查找效率最高。但由于二分查找要求表中结点按关键字有序，且不能用链表作存储结构，因此，当表的插入或删除操作频繁时，为维护表的有序性，势必要移动表中很多结点。这种由移动结点引起的额外时间开销，就会抵消二分查找的优点。也就是说，二分查找只适用于静态查找表。若要对动态查找表进行高效率的查找，可采用下面介绍的几种特殊的二叉树或树作为表的组织形式。不妨
【数据结构】二叉排序树，AVL树，B，B+树总结
mengaliu_123的博客
09-24 1419
二叉排序树简介： 二叉排序树是对普通二叉树的基础上对根、左、右结点做了关键字大小上的限制。优点 在查找时可根据左右子节点与根节点的大小关系进行，减少顺序查找的时间复杂度。缺点： 由于一个排序序列转化成一颗二叉排序树，有多种形式。因此，在某些情况下，二叉排序树的查找时间复杂度不可估量，在最坏的情况下，退化成顺序查找的情况。AVL树简介： AVL树是在二叉排序树的基础上增加了平衡因子的概念，对每
二叉树的好处（应用）
热门推荐
sinat_23619409的博客
05-14 2万+
点击打开链接https://blog.csdn.net/zealot_2002/article/details/8244436二叉排序树是一种比较有用的折衷方案。    数组的搜索比较方便，可以直接用下标，但删除或者插入某些元素就比较麻烦。    链表与之相反，删除和插入元素很快，但查找很慢。    二叉排序树就既有链表的好处，也有数组的好处。    在处理大批量的动态的数据是比较有用。 文件系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值