数据结构——二叉搜索树

已于 2024-03-27 10:42:13 修改
阅读量511 收藏
点赞数
分类专栏： # 数据结构 文章标签： 数据结构 算法 二叉树 二分查找 链表
于 2022-01-07 09:56:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35258036/article/details/122358287
版权

二叉搜索树

二叉搜索树实现（基于链表）

除叶节点外，其余节点中左节点小于父节点，右节点大于父节点，其通常用于查找（二分查找）

代码实现

  • add()方法：当根节点为空时，则新元素即为根节点，否则循环判断新元素放左边还是右边
  • getParent()：从根节点开始寻找指定节点的父节点
  • MaxNode()和Max()：获取最大的节点及其对应的值
  • MinNode()和Min()：获取最小的节点及其对应的值
  • innerSearch()和search()：递归找到对应的值返回boolean
  • visitNode()、midOrderTraversal()和innerMidOrderTraversal()：中序遍历，用于打印验证树结果是否正确
  • remove()：删除，在下面测试代码中介绍

getPre()：获取指定节点的前驱节点（如寻找10的前驱节点pre），分以下情况

  • 情况1：若该节点有左子树，其前驱节点是其左子树中值最大的节点（添加11-10-8-7-9，pre=9）
  • 情况2：若该节点无左子树，那么判断该节点和其父节点的关系
  • 情况2-1：若该节点是无左子树的根节点，无前驱节点（添加10-11-12，pre=null）
  • 情况2-2：若该节点是其父节点的右节点，其前驱结点即为其父节点（添加9-10-11，pre=9）
  • 情况2-3：若该节点是其父节点的左节点，其前驱节点为第一个小于该节点的父节点(添加8-9-11-10，pre=9)，无则为null（添加13-10-11，pre=null）

getSuc()：获取指定节点的后继节点（如寻找10的后继节点suc），分以下情况

  • 情况1：若该节点有右子树，其后继节点是其右子树中值最小的节点（添加9-10-12-11-13，suc=11）
  • 情况2：若该节点无右子树，那么判断该节点和其父节点的关系
  • 情况2-1：若该节点是无右子树的根节点，无后继节点（添加10-9-8，suc=null）
  • 情况2-2：若该节点是其父节点的左节点，其后继结点即为其父节点（添加11-10-9，suc=11）
  • 情况2-3：若该节点是其父节点的右节点，其后继结点为第一个大于该节点的父节点(添加11-9-8-10，suc=11)，无则为null（添加8-10-9，suc=null）
class BinarySearchTree {

    private class TreeNode {

        int value;
        TreeNode leftChild;
        TreeNode rightChild;

        TreeNode(int value) {
            this.value = value;
        }
    }

    private TreeNode root;

    public void add(int value) {
        if (root == null) {
            root = new TreeNode(value);
        } else {
            TreeNode parent;
            TreeNode current = root;
            while (true) {
                parent = current;
                if (value < current.value) {
                    current = current.leftChild;
                    if (current == null) {
                        parent.leftChild = new TreeNode(value);
                        return;
                    }
                } else {
                    current = current.rightChild;
                    if (current == null) {
                        parent.rightChild = new TreeNode(value);
                        return;
                    }
                }
            }
        }
    }

    private TreeNode getPre(TreeNode node) {
        if (node.leftChild != null) {
            return MaxNode(node.leftChild);
        } else {
            TreeNode parent = getParent(node);
            if (parent == null) {
                return null;
            }
            if (node == parent.rightChild) {
                return parent;
            } else {    //node == parent.leftChild
                while (parent != null) {
                    if (parent.value < node.value) {
                        break;
                    }
                    parent = getParent(node);
                }
                return parent;
            }
        }
    }

    private TreeNode getSuc(TreeNode node) {
        if (node.rightChild != null) {
            return MinNode(node.rightChild);
        } else {
            TreeNode parent = getParent(node);
            if (parent == null) {
                return null;
            }
            if (node == parent.leftChild) {
                return parent;
            } else {    //node == parent.rightChild
                while (parent != null) {
                    if (parent.value > node.value) {
                        break;
                    }
                    parent = getParent(node);
                }
                return parent;
            }
        }
    }

    private TreeNode getParent(TreeNode node) {
        if (root == node) {
            return null;
        }
        if (node == null) {
            return null;
        }
        TreeNode current = root;
        TreeNode parent = null;
        while (current != null) {
            if (node.value < current.value) {
                parent = current;
                current = current.leftChild;
            } else if (node.value > current.value) {
                parent = current;
                current = current.rightChild;
            } else {
                return parent;
            }
        }
        return parent;
    }

    public void Max() {
        TreeNode maxNode = MaxNode(root);
        if (maxNode != null) {
            visitNode(maxNode);
        } else {
            System.out.print("null");
        }
    }

    private TreeNode MaxNode(TreeNode node) {
        if (node == null) {
            return null;
        }
        TreeNode current = node;
        while (current.rightChild != null) {
            current = current.rightChild;
        }
        return current;
    }

    public void Min() {
        TreeNode minNode = MinNode(root);
        if (minNode != null) {
            visitNode(minNode);
        } else {
            System.out.print("null");
        }
    }

    private TreeNode MinNode(TreeNode node) {
        if (node == null) {
            return null;
        }
        TreeNode current = node;
        while (current.leftChild != null) {
            current = current.leftChild;
        }
        return current;
    }

    public boolean search(int value) {
        if (innerSearch(root, value) != null) {
            return true;
        } else {
            return false;
        }
    }

    private TreeNode innerSearch(TreeNode root, int value) {
        if (root == null) {
            return null;
        }
        if (value < root.value) {
            return innerSearch(root.leftChild, value);
        } else if (value > root.value) {
            return innerSearch(root.rightChild, value);
        } else {
            return root;
        }
    }

    private void visitNode(TreeNode node) {
        System.out.print(node.value + " ");
    }

    public void midOrderTraversal() {
        innerMidOrderTraversal(root);
    }

    private void innerMidOrderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        innerMidOrderTraversal(root.leftChild);
        visitNode(root);
        innerMidOrderTraversal(root.rightChild);
    }

    public void remove(int value) {
        TreeNode delNode = innerSearch(root, value);
        TreeNode parent = getParent(delNode);
        if (delNode.leftChild == null && delNode.rightChild == null) {  //删除的节点无左右节点，则断开父节点和它的连接（若是根节点则置空）
            if (parent == null) {   //delNode = root
                root = null;
            } else {
                if (delNode == parent.leftChild) {
                    parent.leftChild = null;
                } else {
                    parent.rightChild = null;
                }
            }
        } else if (delNode.leftChild == null && delNode.rightChild != null) { //删除的节点有右节点，则让其右节点连上父节点（若是根节点，则右节点成为新根节点）
            if (parent == null) {   //delNode = root
                root = delNode.rightChild;
            } else {
                if (delNode == parent.leftChild) {
                    parent.leftChild = delNode.rightChild;
                } else {
                    parent.rightChild = delNode.rightChild;
                }
            }
        } else if (delNode.leftChild != null && delNode.rightChild == null) { //删除的节点有左节点，则让其左节点连上父节点（若是根节点，则左节点成为新根节点）
            if (parent == null) {   //delNode = root
                root = delNode.leftChild;
            } else {
                if (delNode == parent.leftChild) {
                    parent.leftChild = delNode.leftChild;
                } else {
                    parent.rightChild = delNode.leftChild;
                }
            }
        } else { //删除的节点左右节点都有
            if (parent == null) {   //delNode = root，则左右节点任意一个都可成为新根节点
                root = delNode.leftChild;
                //root = delNode.rightChild;
            } else {

                System.out.print("删除的节点：");
                visitNode(delNode);
                System.out.println();

                System.out.print("删除节点的后继节点：");
                TreeNode successor = getSuc(delNode);
                if (successor == null) {
                    System.out.print("null");
                } else {
                    visitNode(successor);
                }
                System.out.println();

                System.out.print("删除节点的后继节点的父节点：");
                TreeNode successorParent = getParent(successor);
                if (successorParent == null) {
                    System.out.print("null");
                } else {
                    visitNode(successorParent);
                }
                System.out.println();

                if (successorParent == delNode) {   //若后继节点是删除节点的右节点
                    parent.rightChild = successor;
                    successor.leftChild = delNode.leftChild;
                    delNode.leftChild = null;
                } else {                  //若后继节点是删除节点的右子树的左节点
                    successorParent.leftChild = successor.rightChild;   //断开successor
                    successor.rightChild = null;

                    parent.leftChild = successor;               //del父节点指向successor，即断开del
                    successor.rightChild = delNode.rightChild;  //successor连接delNode右子树
                    delNode.rightChild = null;                  //断开delNode右子树

                    successor.leftChild = delNode.leftChild;    //successor连接delNode左子树
                    delNode.leftChild = null;                   //断开delNode左子树
                }
            }
        }
    }
}

测试代码1

下面代码测试添加、遍历、最大最小值

BinarySearchTree binarySearchTree = new BinarySearchTree();
binarySearchTree.add(3);
binarySearchTree.add(5);
binarySearchTree.add(2);
binarySearchTree.add(1);
binarySearchTree.add(4);

System.out.print("add后中序遍历测试：");
binarySearchTree.midOrderTraversal();
System.out.println();

System.out.print("最大值:");
binarySearchTree.Max();
System.out.println();

System.out.print("最小值:");
binarySearchTree.Min();
System.out.println();

System.out.print("查找value=2：");
if (binarySearchTree.search(2)) {
    System.out.print("found");
} else {
    System.out.print("not found");
}
System.out.println();

打印如下

add后中序遍历测试：1 2 3 4 5 
最大值:5 
最小值:1 
查找value=2：found

测试代码2

下面单独测试删除

  • 情况1：删除的节点无左右节点（添加1-2，删除2），则断开父节点和它的连接（若是根节点则置空）
  • 打印：remove前中序遍历为：1 2 ————> remove后中序遍历为：1
BinarySearchTree binarySearchTree = new BinarySearchTree();
binarySearchTree.add(1);
binarySearchTree.add(2);

System.out.print("remove前中序遍历为：");
binarySearchTree.midOrderTraversal();
System.out.print("————> remove后中序遍历为：");
binarySearchTree.remove(2);
binarySearchTree.midOrderTraversal();
System.out.println();
  • 情况2：删除的节点有右节点无左节点（添加1-2-3，删除2），则让其右节点连上其父节点（若是根节点，则右节点成为新根节点）
  • 打印：remove前中序遍历为：1 2 3 ————> remove后中序遍历为：1 3
BinarySearchTree binarySearchTree = new BinarySearchTree();
binarySearchTree.add(1);
binarySearchTree.add(2);
binarySearchTree.add(3);

System.out.print("remove前中序遍历为：");
binarySearchTree.midOrderTraversal();
System.out.print("————> remove后中序遍历为：");
binarySearchTree.remove(2);
binarySearchTree.midOrderTraversal();
System.out.println();
  • 情况3：删除的节点有左节点无右节点（添加3-2-1，删除2），则让其左节点连上其父节点（若是根节点，则右节点成为新根节点）
  • 打印：remove前中序遍历为：1 2 3 ————> remove后中序遍历为：1 3
BinarySearchTree binarySearchTree = new BinarySearchTree();
binarySearchTree.add(3);
binarySearchTree.add(2);
binarySearchTree.add(1);
System.out.print("remove前中序遍历为：");
binarySearchTree.midOrderTraversal();

System.out.print("————> remove后中序遍历为：");
binarySearchTree.remove(2);
binarySearchTree.midOrderTraversal();
System.out.println();
  • 情况4-1：删除的节点既有左节点又有右节点，其后继节点为待删除节点的右节点（添加2-4-3-6-9-7，删除4）
  • 操作为：待删除节点的父节点的右节点指向其后继节点，后继节点的左节点指向待删除节点的左节点，断开待删除节点的左节点
BinarySearchTree binarySearchTree = new BinarySearchTree();
binarySearchTree.add(2);
binarySearchTree.add(4);
binarySearchTree.add(3);
binarySearchTree.add(6);
binarySearchTree.add(9);
binarySearchTree.add(7);

System.out.print("remove前中序遍历为：");
binarySearchTree.midOrderTraversal();
System.out.println();

binarySearchTree.remove(4);
System.out.print("remove后中序遍历为：");
binarySearchTree.midOrderTraversal();
System.out.println();

打印如下

remove前中序遍历为：2 3 4 6 7 9 
删除的节点：4 
删除节点的后继节点：6 
删除节点的后继节点的父节点：4 
remove后中序遍历为：2 3 6 7 9
  • 情况4-2：删除的节点既有左节点又有右节点，其后继节点为待删除节点的右子树的左节点（添加10-4-3-8-9-6-7，删除4）
  • 操作为：①后继节点的父节点的左节点指向后继节点的右节点，断开后继节点的右节点。②待删除节点的父节点的左节点指向后继节点，后继节点的右节点指向待删除节点的右节点，断开待删除节点的右节点。③后继节点的左节点指向待删除节点的左节点，断开待删除节点的左节点
BinarySearchTree binarySearchTree = new BinarySearchTree();
binarySearchTree.add(10);
binarySearchTree.add(4);
binarySearchTree.add(3);
binarySearchTree.add(8);
binarySearchTree.add(9);
binarySearchTree.add(6);
binarySearchTree.add(7);
//binarySearchTree.add(5);

System.out.print("remove前中序遍历为：");
binarySearchTree.midOrderTraversal();
System.out.println();

binarySearchTree.remove(4);
System.out.print("remove后中序遍历为：");
binarySearchTree.midOrderTraversal();
System.out.println();

打印如下

remove前中序遍历为：3 4 6 7 8 9 10 
删除的节点：4 
删除节点的后继节点：6 
删除节点的后继节点的父节点：8 
remove后中序遍历为：3 6 7 8 9 10

时间复杂度和优化

  • 最好情况：如果二叉搜索树刚好对半平分，n个节点的二叉搜索树的高度为log2n+1，复杂度为O(logn)，同二分查找法

  • 最坏情况：如果二叉搜索树完全斜向一边，高度为n，复杂度为O(n)，退化为顺序查找法

为了获得较好的查找性能，就要构造一棵平衡的二叉搜索树

松仔log
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构平衡二叉排序树
02-13
AVL树是一种自平衡的二叉搜索树，它的每个节点都包含一个平衡因子，这个因子是该节点的左子树高度与右子树高度的差值。平衡因子的取值范围是-1、0或1，这确保了树的高度始终保持在一个相对较小的范围内，从而保证了...
课程设计——二叉查找树
03-13
在这个“课程设计——二叉查找树”项目中，开发者创建了一个桌面应用程序，用于实现对二叉查找树的操作。用户可以通过界面进行交互，进行查找操作，同时能够直观地观察到操作的结果。这对于学习和理解二叉查找树的...
最优二叉查找树（动态规划）——详解
热门推荐
weixin_44023658的博客
05-07 3万+
最优二叉查找树 (1）二叉查找树（二分检索树）二叉搜索树 Ｔ是一棵二元树，它或者为空，或者其每个结点含有一个可以比较大小的数据元素，且有： Ｔ的左子树的所有元素比根结点中的元素小； Ｔ的右子树的所有元素比根结点中的元素大； Ｔ的左子树和右子树也是二叉搜索树。 (2）最优二叉搜索树 给定一个n个关键字的已排序的序列K=<k 1 ,k 2 ,…,k n >（ 不失一般性，设k 1 &...
二叉查找树和二叉堆
weixin_30950887的博客
07-15 446
A.　二叉查找树(Binary Search Tree)，又称为有序二叉树，排序二叉树，满足以下性质： 1）没有键值相等的节点。 2）若左子树不为空，左子树上节点值均小于根节点的值。 3）若右子树不为空，右子树上节点值均大于根节点的值。 　　二叉查找树中对于目标节点的查找过程类似与有序数组的二分查找，并且查找次数不会超过树的深度。设节点数目为n，树的深度为h，假设树的每层都被塞满(第L层有...
数据结构——二叉搜索树详解
rab1211764820的博客
03-26 663
二叉搜索树的递归实现 二叉搜索树的非递归实现 二叉搜索树的查找、插入、删除
Java数据结构——二叉搜索树
chenchenchencl的博客
10-19 1274
Java数据结构——二叉搜索树
数据结构——二叉搜索树 Python实现
2301_80278591的博客
04-18 744
基于二叉搜索树每个节点中的数值大小均满足：左子节点的值 < 根节点的值 < 右子节点的值的特点，二叉搜索树在搜索值时是依照二分来进行查找的，即先将待查找的值与每棵子树的根节点的值进行比较，当待查找的值小于每棵子树的根节点的值时，到该根节点的左子树递归查找；二叉树的许多相关操作是和递归密不可分的。所谓二叉搜索树，其实本质上就是一个树状的数据结构，也是有一个根节点和若干个子树所组成的，其基于二叉树的结构，而在其数据的填充位置上所进行优化而得到的数据结构，并运用二叉搜索树数据的分布特点来实现在搜索功能。
17、python数据结构——二叉搜索树
weixin_56504083的博客
03-24 734
二叉搜索树事一颗二叉树且满足性质：设x是二叉搜索树的一个节点，如果y是x左子树的一个节点，那么y.key = x.key。
C++数据结构——二叉搜索树（详细图解，详细代码实现）
Zfox的博客
07-18 894
详细讲解了C++数据结构的二叉搜索树的实现
基础数据结构——二叉搜索树
weixin_60778429的博客
07-04 384
目录1.二叉搜索树的概念2.基本功能实现3.完整代码及性能分析二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树具体我们可以看到下图就是一棵二叉搜索树 同时我们也可以注意到按照中序遍历的方法去遍历一棵二叉搜索树他的结果一定是有序的。由上述性质我们可以知道二叉树的左节点一定小于当前根节点,右节点一定大于当前根节点。所以我们可以得到以下查找的方法。由以上操作我们可以得到下面的代码: 2.2 插入 在插入同时我们也需要满足二叉搜索树的基本性质,同时我们也不允许存在重复元素。 2
高级数据结构——二叉搜索树
m0_49687898的博客
06-21 1288
1. 二叉搜索树的概念2. 二叉搜索树的实现 结点类 二叉搜索树的类 2.1默认成员函数2.1.1 构造函数2.1.2 拷贝构造函数2.1.3 赋值运算符重载函数2.1.4 析构函数2.2 中序遍历2.3 insert插入函数2.3.1 非递归实现2.3.2 递归实现2.4 erase删除函数2.4.1 非递归实现2.4.2 递归版本2.5 find查找函数2.5.1 非递归实现2.5.2递归实现3. 二叉搜搜数的应用3.1 k模
数据结构示例(五)——二叉搜索树.doc
10-10
数据结构示例(五)——二叉搜索树.doc
数据结构课程设计——二叉排序树
02-18
### 数据结构课程设计——二叉排序树 #### 一、二叉排序树概念 二叉排序树(Binary Search Tree)，也称作二叉查找树或有序二叉树，是一种特殊的二叉树数据结构。它具有以下性质： 1. 若任意节点的左子树不空，则左...
数据结构实验——树和二叉树子系统
07-31
在本实验“数据结构实验——树和二叉树子系统”中，我们将深入理解二叉树的特性和操作。 首先，实验目的主要涵盖以下几个方面： 1. **理解二叉树特点**：二叉树的每个节点至多有两个子节点，它允许快速查找、插入...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 270
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 405
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
java算法原理
jylee的博客
07-25 834
正确回答通过率：40.0%[ 详情 ] 推荐指数： ★★★★ 试题难度： 高难 试题类型： 编程题 ▸ 写笔记试题回答参考思路： >>
数据结构的概念和术语
2303_78660417的博客
07-24 524
数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科。数据结构的基本数据结构包括两部分，线性结构跟非线性结构。
平衡二叉搜索树与并查集——高级数据结构解析
"这篇资料主要介绍了什么是好的BST算法以及与之相关的高级数据结构，包括并查集、二叉树和二叉搜索树等概念。华东理工大学的罗勇军教授提供了相关课程内容，强调了BST的平衡性对于其性能的重要性，并简述了并查集在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值