树3--二叉排序树

于 2020-09-17 11:07:33 发布
阅读量131 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43203735/article/details/108638361
版权

二叉排序树

在线性表中，我们可以通过数组和链表对数据进行查询、添加、删除。

在数组中查询的时间复杂度为O(1) , 添加删除的操作时间复杂度为O(n)

在链表中查询的时间复杂度为O(n) ，添加删除的操作时间复杂度为O(1) 【且当前已找到需要删除的数据】

因此我们通过二叉树来存储数据，以及与数据的一些处理。

二叉排序树的定义

二叉排序树(BST)，又称二叉查找树、二叉搜索树。

对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点比当前节点的值大。

特别说明，如果有相同的值，可以将该节点放在左子节点或右子节点。

比如对下面的一组数据（7，3，10，8，5，15，1），二叉排序树为：
在这里插入图片描述

验证是否为二叉树：
在这里插入图片描述

同样我们也可以进行中序遍历来验证

二叉排序树的创建和遍历

创建

在这里插入图片描述

在这里插入图片描述

之后的节点添加都类似。
最后添加完成

在这里插入图片描述

代码：

class Node{
    public int val;
    public Node leftNode;
    public Node rightNode;

    public Node(int i) {
        this.val = i;
    }

    //中序遍历
    public void infixOrder(){
        if(this.leftNode != null){
            this.leftNode.infixOrder();
        }

        System.out.print(this.val + "\t");

        if(this.rightNode != null){
            this.rightNode.infixOrder();
        }
    }

    //添加节点
    public void add(Node node){
        if(node == null)
            return;
        //如果新添加节点小于当前节点
        if(node.val < this.val){
            if(this.leftNode == null){
                this.leftNode = node;
            }else{
                this.leftNode.add(node);
            }
        }else{//如果新添加节点大于等于当前节点
            if(this.rightNode == null){
                this.rightNode = node;
            }else{
                this.rightNode.add(node);
            }
        }


    }
}

class Tree{
    private Node root;

    public Tree() {
    }

    //中序遍历
    public void infixOrder(){
        if(this.root != null){
            this.root.infixOrder();
        }else{
            System.out.println("二叉排序树为空");
        }
    }

    //二叉排序树添加节点
    public void add(Node node){
        if(root == null){
            root = node;
        }else{
            root.add(node);
        }
    }
}


public class BinarySortTree {

    public static void main(String[] args) {
        Node node1 = new Node(7);
        Node node2 = new Node(3);
        Node node3 = new Node(10);
        Node node4 = new Node(8);
        Node node5 = new Node(5);
        Node node6 = new Node(15);
        Node node7 = new Node(1);

        Tree tree = new Tree();

        tree.add(node1);
        tree.add(node2);
        tree.add(node3);
        tree.add(node4);
        tree.add(node5);
        tree.add(node6);
        tree.add(node7);

        tree.infixOrder();   	//1	 3 	 5	 7	 8	 10	 15	

    }
}

二叉排序树的删除

二叉排序树的删除需要考虑三种情况：

1、删除叶子节点

2、删除只有一个子树的节点

3、删除有两颗子树的节点

我们重新创建一个二叉排序树，节点值为：【7，3，10，12，5，1，9，2】

二叉排序树为：
在这里插入图片描述

第一种情况：删除节点2、5、9、12

1、找到需要删除的节点

2、找到需要删除节点的父节点

3、判断需要删除节点是父节点的左子节点或右子节点

4、如果为左子节点，parent.leftNode = null，如果为右子节点，parent.rightNode = null

删除节点2之后：
在这里插入图片描述

第二种情况：删除节点1

1、找到需要删除的节点targetNode

2、找到targetNode的父节点parent

3、确定targetNode的子结点是左子结点还是右子节点

4、确定targetNode是parent的左子节点还是右子节点。

5、如果targetNode有左子节点

​ 5.1、如果targetNode是parent的左子节点 parent.leftNode = targetNode.left;

​ 5.2、如果targetNode是parent的右子节点 parent.rightNode = targetNode.left;

6、如果targetNode有右子节点

​ 5.1、如果targetNode是parent的左子节点 parent.leftNode = targetNode.right;

​ 5.2、如果targetNode是parent的右子节点 parent.rightNode = targetNode.right;

删除节点1之后：
在这里插入图片描述

第三种情况 ：删除节点3，10

1、找到需要删除的节点targetNode

2、找到targetNode的父节点parent

3、从targetNode的右子树中找到最小的节点【或者左子树中找到最大节点】 。

4、用一个临时变量，将最小的节点的值保存到temp中。

5、删除右子树中最小的节点【或左子树中最大的节点】

6、targetNode.val = temp;

删除节点3之后：

在这里插入图片描述

代码：

class Node{
    public int val;
    public Node leftNode;
    public Node rightNode;

    public Node(int i) {
        this.val = i;
    }

    //中序遍历
    public void infixOrder(){
        if(this.leftNode != null){
            this.leftNode.infixOrder();
        }

        System.out.print(this.val + "\t");

        if(this.rightNode != null){
            this.rightNode.infixOrder();
        }
    }

    //添加节点
    public void add(Node node){
        if(node == null)
            return;
        //如果新添加节点小于当前节点
        if(node.val < this.val){
            if(this.leftNode == null){
                this.leftNode = node;
            }else{
                this.leftNode.add(node);
            }
        }else{//如果新添加节点大于等于当前节点
            if(this.rightNode == null){
                this.rightNode = node;
            }else{
                this.rightNode.add(node);
            }
        }


    }

    //查找需要删除的节点
    public Node Search(int val){
        if(this.val == val){
            return this;
        }else if(this.val < val){
            if(this.rightNode == null)
                return null;
            return this.rightNode.Search(val);
        }else{
            if(this.leftNode == null)
                return null;

            return this.leftNode.Search(val);
        }
    }

    //查找需要删除节点的父节点
    public Node SearchParent(int val){
        if((this.leftNode != null && this.leftNode.val == val) || (this.rightNode != null && this.rightNode.val == val)) {
            return this;
        }else{
            //如果查找的值小于当前节点的值，并且当前节点的左子节点不为空
            if (val < this.val && this.leftNode != null){
                return this.leftNode.SearchParent(val);
            }else if (val >= this.val && this.rightNode != null){
                return this.rightNode.SearchParent(val);
            }else{
                return null;
            }
        }
    }

}

class Tree{
    private Node root;

    public Tree() {
    }

    //中序遍历
    public void infixOrder(){
        if(this.root != null){
            this.root.infixOrder();
        }else{
            System.out.println("二叉排序树为空");
        }
    }

    //二叉排序树添加节点
    public void add(Node node){
        if(root == null){
            root = node;
        }else{
            root.add(node);
        }
    }


    //查找需要删除的节点
    public Node Search(int val){
        if(root == null){
            return null;
        }else{
            return root.Search(val);
        }
    }

    //查找父节点
    public Node SearchParent(int val){
        if(this.root == null) {
            return null;
        }else{
            return root.SearchParent(val);
        }


    }

    //找到需要删除节点的右子树的最小值
    public int delRightTreeMin(Node node){
        Node target = node;
        while(target.leftNode != null){
            target = target.leftNode;
        }

        delNode(target.val);

        return target.val;
    }


    //删除节点
    public void delNode(int val){
        if(root == null) {
            return;
        } else{
            //1、找到需要删除的节点
            Node targetNode = Search(val);
            if(targetNode == null){
                return;
            }

            //如果当前二叉排序树只有一个节点
            if(root.leftNode == null || root.rightNode == null){
                root = null;
                return;
            }

            //找到targetNode 的父节点,因为不是根节点，所以一定右父节点
            Node parent = SearchParent(val);

            //如果要删除的节点是叶子节点
            if(targetNode.leftNode == null && targetNode.rightNode == null){
                if(parent.leftNode != null && parent.leftNode.val == val){
                    parent.leftNode = null;
                }else if(parent.rightNode != null && parent.rightNode.val == val){
                    parent.rightNode = null;
                }
                //如果删除的节点右两个子结点
            }else if(targetNode.leftNode != null && targetNode.rightNode != null){
                int minVal = delRightTreeMin(targetNode.rightNode);
                targetNode.val = minVal;
            }else{//如果删除的节点只有一个子结点
                //子结点为左节点时
                if(targetNode.leftNode != null){
                    if(parent != null){
                        if(parent.leftNode.val == val){
                            parent.leftNode = targetNode.leftNode;
                        }else{
                            parent.rightNode = targetNode.leftNode;
                        }
                    }else{
                        root = targetNode.leftNode;
                    }
                }else{
                    //子结点为右节点时
                    if(parent != null){
                        if(parent.leftNode.val == val){
                            parent.leftNode = targetNode.rightNode;
                        }else{
                            parent.rightNode = targetNode.rightNode;
                        }
                    }else{
                        root = targetNode.rightNode;
                    }
                }
            }
        }
    }

}

测试：

public static void main(String[] args) {
    Node node1 = new Node(7);
    Node node2 = new Node(3);
    Node node3 = new Node(10);
    Node node4 = new Node(12);
    Node node5 = new Node(5);
    Node node6 = new Node(1);
    Node node7 = new Node(9);
    Node node8 = new Node(2);

    Tree tree = new Tree();

    tree.add(node1);
    tree.add(node2);
    tree.add(node3);
    tree.add(node4);
    tree.add(node5);
    tree.add(node6);
    tree.add(node7);
    tree.add(node8);

    tree.infixOrder();
    System.out.println();

    tree.delNode(1);  //2  3  5  7  9  10 12
    tree.delNode(12);  //2 3  5  7  9  10
    tree.delNode(10);   //2 3  5  7  9
    tree.infixOrder();  
}
JiangZW187
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构复习总结】—— 树
小牛肉的博客
03-24 605
一、思维导图 二、基本概念和性质 三、二叉树的存储结构 顺序存储 链式存储 四、二叉树的三种遍历+层次遍历 先序遍历 中序遍历 后序遍历 层次遍历 五、二叉排序树BST / 二叉查找树 定义 插入和删除操作 二叉排序树的判定 六、平衡二叉树AVL 定义 插入操作（每次调整对象都是最小不平衡子树） 平衡二叉树的判定 完全二叉树的判定 七、哈夫曼树（最优二叉树）和哈夫曼编码 定义 构造方法 哈夫曼编码 八、树、森林、二叉树的转换 树转化为二叉树 森林转化为二叉树 二叉树转化为森林
二叉树常见的问题和解决思路
weixin_39861267的博客
06-27 3154
二叉树的各种操作
按照二叉树的定义,具有 3 个结点的二叉树有（ ）种
热门推荐
天道酬勤，且行且思，勿思而不行
10-19 3万+
[color=red]按照二叉树的定义,具有 3 个结点的二叉树有（ ）种 [/color] 一共有5种： 解析： 1.根节点 左儿子 右儿子 2.根节点 只有左子树 左子树中只有根节点和左儿子 3.根节点 只有左子树 左子树中只有根节点和右儿子 4.根节点 只有右子树 右子树中只有根节点和左儿子 5.根节点 只有右子树 右子树中只有根节点和右儿子 [img]G:/火狐网上下载/二叉树3结点和种...
数据结构——二叉排序树(BST)+图文精讲
girls的博客
08-17 6621
二叉排序树（简称BST） 又称二叉查找（搜索）树，其定义为：二叉排序树或者是空树，或者是满足如下性质（BST性质）的二叉树： ①： 若它的左子树非空，则左子树上所有结点值（指关键字值）均小于根结点值； ②： 若它的右子树非空，则右子树上所有结点值均大于根结点值； ③： 左、右子树本身又各是一棵二叉排序树。 注意：二叉排序树中没有相同关键字的结点。 二叉排序树的中序遍历序列有什么特点？ 答：中序遍历二叉排序树会得到一个升序的序列。 二叉排序树的结点类型如下： typedef struct node {
数据结构-二叉排序树BST（基础知识）
abcnull 的博客
02-29 742
二叉排序树简介 二叉排序树（BST） 二叉排序树又称为二叉查找树，即 BinarySearchTree（BST），左子树所有结点值小于等于根结点值，根结点值小于等于右子树任意一个结点值，左右子树分别又是一颗二叉排序树 这个很符合中序遍历的顺序对不对(#.#) 二叉排序树的优势 由于是二叉排序树，当我们要去寻找某个数值的结点时候会变得非常容易，为什么呢？因为形象的说二叉排序树通过根结点把一个结构分成...
java--实现二叉排序树
04-23
二叉排序树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它具有以下特性： 1. 每个节点包含一个键（key）、一个关联的值、一个指向左子节点的引用和一个指向右子节点的引用。 2. 节点的键大于其左子树...
cpp-二叉树以及二叉排序树的实现
08-16
在IT领域，二叉树和二叉排序树是数据结构中的重要组成部分，它们在算法设计和程序实现中扮演着至关重要的角色。本文将深入探讨这两种数据结构的理论基础、实现方式以及它们在C/C++编程中的应用。 首先，我们要了解...
二叉排序树的实现与基本操作
08-31
3. 左右子树都是二叉排序树。 二叉排序树的实现通常包括节点的创建、插入、删除以及遍历等操作。在提供的代码中，实现了以下功能： **二叉树的构建**： 通过`insert`方法，可以向二叉排序树中插入新节点。当树为空...
数据结构实验-二叉排序树算法
10-26
掌握二叉排序树的存储方法，实现二叉排序树的创建、查找、插入、删除、平均查找长度等基本操作。 三、实验内容及要求 1、构造二叉排序树的存储结构。 2、实现创建、查找、插入、删除、平均查找长度等操作。
数据结构---二叉排序树.doc
10-10
数据结构---二叉排序树.doc
高级数据结构之BST（一）
禾露悠悠摇的博客
07-05 1717
1、树的节点包含一个数据元素，以及若干指向其子树的分支。节点拥有的子树的数量称为节点的度。节点的最大层次称为树的深度或高度。 2、二叉树是一种树形结构，其特点是每个节点至多有两棵子树，且子树有左右之分，次序不能随意颠倒。 3、满二叉树：一棵深度为k且有2^k - 1个节点的二叉树，称之为满二叉树。 4、完全二叉树：对一个深度为k，节点个数为n的二叉树，当且仅当每个节点都与深度为k的满二叉树中...
【Java数据结构】二叉排序树
萌宅鹿的技术小屋
09-19 352
二叉排序树为什么需要二叉排序树？什么是二叉排序树（BST）？ 为什么需要二叉排序树？ 假设有一组数字，｛7，3，10，12，5，1，9｝，面对这么一组数字，我们有很多种方式来存储他们。 例如线性结构中不排序的顺序存储结构： 对这种数据结构来说，它查找某个元素十分的困难，需要从头到尾挨个去寻找。 线性结构中排序的顺序存储结构： 哪怕是排序过后的该种数据结构，通过二分查找，它的查找效率会变高，但是...
数据结构（34）二叉排序树
李白
06-20 1万+
目录 1、二叉排序树（BST,Binary Sort Tree）定义 2、二叉排序树的查找 3、二叉排序树的插入 4、二叉排序树的构造 6、二叉排序树的查找效率分析 7、二叉排序树与二分排序对比 1、二叉排序树（BST,Binary Sort Tree）定义 二叉排序树（也称为二叉查找树）或者是一棵空树，或者是具有以下特性的二叉树： 1）若左子树非空，则左子树上所有结点的值均小于根节点的值。 2）若右子树非空，则右子树上所有结点的值均大于根节点的值。 3）左、右子树也分别是一棵二叉排序
数据结构之二叉排序树
顾小豆的博客
03-06 1187
上一节我们介绍了二分（折半）查找，也了解了它的优缺点。二分查找的特点:二分查找能够提高有序表中数据元素的查找速度；二分查找的时间复杂度为O(log2n)；二分查找是一种静态查找二分查找的不足：当查找表经常变化时，二分查找的整体性能急剧下降。二分查找的硬伤：二分查找基于有序表。 当需要插入或者删除数据元素时，为了能够继续进行二分查找，需要大规...
【数据结构】二叉排序树BST
weixin_30872733的博客
11-14 160
二叉排序树 二叉排序树(Binary Sort Tree)也叫二叉搜索树(Binary Search Tree) 二叉排序树本质上还是一个二叉树，只不过在其上定义了一些规则：一个结点的左子树中所有的结点不大于该结点的值，而其右子树中的所有结点不小于该结点的值。由此规则可得BST中序遍历是有序的。 BST中定义的操作有： minNode：某个子树中的关键字最小的结点 maxNode...
【树3】满二叉树、完全二叉树、完美二叉树
weixin_33850015的博客
09-19 255
---------注：本文所用的术语定义均来自国外大学和计算机文献使用的定义，非国内教材。层次编号从1开始------------- 满二叉树（Full Binary Tree） 定义：a binary tree T is full if each node is either a leaf or possesses exactly two child nodes. 大意：每一个结点要么度为...
详细教你实现BST(二叉排序树)
Saber00001的博客
12-02 323
查找基本分类如下： 线性表的查找 顺序查找 折半查找 分块查找 树表的查找 二叉排序树 平衡二叉树 B树 B+树 散列表的查找 今天介绍二叉排序树。 二叉排序树 ( Binary Sort Tree ) 又称为二叉查找树，它是一种对排序和查找都很有用的特殊二叉树。 1. 二叉排序树的定义 二叉排序树是具有如下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值均小于...
查找算法三之二叉排序树
山之巅的专栏
05-10 1278
在学习查找算法的时候说过，当时you对树的操作不熟练，所以关于二叉搜索树、B树这些动态查找都没有练习，这一节补上，这一节介绍二叉搜索树。    二叉搜索树，书上叫二叉排序树或者二叉查找树，首先看定义，二叉排序树或者是一颗空树，或者是具有下列性质的二叉树：(1)若他的左子树不空，则左子树上所有结点的值均小于它的根结点的值；(2)若他的右子树不空，则右子树上所有结点的值均大于它的根结点的值；(3)它
数据结构知识整理 - 二叉排序树
春雪阁
12-11 2029
  主要内容 前提 二叉排序树（Binary Sort Tree） 数据结构 查找算法 插入算法 创建算法 删除算法   前提 （可回顾“基本概念”） 若在查找的同时对表做插入、删除等修改操作，则被查找的表称为动态查找表，反之则称为静态查找表。 换句话说，动态查找表的表结构本身是在查找过程中动态生成的，即在创建表时，对于给定值，若表中存在其关键字等于给定值的记录，则返回“已...
PTA6-2 查找二叉排序树
最新发布
05-23
题目描述： 给定一棵二叉排序树和一个值，求该值在树中出现的次数。 输入格式： 第一行包含整数 n，表示树中节点个数。 接下来 n 行，每行包含一个整数，表示当前节点的值。 最后一行包含一个整数x，表示需要统计出现次数的值。 输出格式： 共一行，包含一个整数，表示该值在树中出现的次数。 输入样例： ``` 5 2 1 2 3 4 2 ``` 输出样例： ``` 2 ``` 算法1： 递归遍历，统计值出现的次数。 时间复杂度 平均时间复杂度为O(logn)，最坏时间复杂度为O(n)。 参考文献 Python 代码 ```python class TreeNode(object): def __init__(self, x): self.val = x self.left = None self.right = None class Solution(object): def searchBST(self, root, val): """ :type root: TreeNode :type val: int :rtype: bool """ if not root: return 0 if val == root.val: return 1 + self.searchBST(root.left, val) + self.searchBST(root.right, val) elif val < root.val: return self.searchBST(root.left, val) else: return self.searchBST(root.right, val) ``` 算法2： 迭代遍历，统计值出现的次数。 时间复杂度 平均时间复杂度为O(logn)，最坏时间复杂度为O(n)。 参考文献 Python 代码 ```python class TreeNode(object): def __init__(self, x): self.val = x self.left = None self.right = None class Solution(object): def searchBST(self, root, val): """ :type root: TreeNode :type val: int :rtype: bool """ if not root: return 0 count = 0 stack = [root] while stack: node = stack.pop() if node.val == val: count += 1 if node.left and node.val >= val: stack.append(node.left) if node.right and node.val <= val: stack.append(node.right) return count ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值