二叉查找树（BST）

最新推荐文章于 2022-11-14 21:42:24 发布
最新推荐文章于 2022-11-14 21:42:24 发布
阅读量158 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 二叉查找树 二叉搜索树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hcmdghv587/article/details/103431397
版权

二叉查找树

代码实现

使用JAVA实现的二叉查找树，支持以下功能：

  1. 插入元素（容器可含有重复的数）
  2. 删除元素（对于相同的元素，只删除一个）
  3. 查询元素的排名（val的排名定义为比val小的数的个数+1）
  4. 根据排名查询元素
  5. 求某个元素的前驱（val的前驱为小于val，且最大的数）
  6. 求某个元素的后继（val的后继为大于val，且最小的数）
  7. 获取容器的尺寸（即容器中的元素数量）
  8. 判断容器是否包含某个元素
  9. 清空容器
package BalancedTree.BST;

import java.util.Stack;

public class BST implements Tree {
    static class Node {
        int val;  // 结点中存储的值
        Node leftChild, rightChild;  // 左孩子和右孩子
        int cnt;  // 该结点所在子树中所有结点的数量

        Node(int val) {
            this.val = val;
            leftChild = rightChild = null;
            cnt = 1;
        }

        // 更新结点的信息，当该结点的子树发生变化后使用
        void update() {
            cnt = 1;
            cnt += leftChild != null ? leftChild.cnt : 0;
            cnt += rightChild != null ? rightChild.cnt : 0;
        }
    }

    private Node root = null;

    // 计算结点node在以node为树根的子树中的排名
    private int nodeRank(Node node) {
        if (node.leftChild != null) {
            return node.leftChild.cnt + 1;
        } else {
            return 1;
        }
    }

    // 插入结点
    public void insert(int val) {
        if (root == null) {
            root = new Node(val);
        } else {
            Node cur = root;
            while (true) {
                ++cur.cnt;
                if (val < cur.val) {
                    if (cur.leftChild == null) {
                        cur.leftChild = new Node(val);
                        break;
                    } else {
                        cur = cur.leftChild;
                    }
                } else {
                    if (cur.rightChild == null) {
                        cur.rightChild = new Node(val);
                        break;
                    } else {
                        cur = cur.rightChild;
                    }
                }
            }
        }
    }

    // 删除值为val的结点
    // 如果存在多个相同的数，只删除一个，返回true
    // 如果不存在，返回false
    public boolean remove(int val) {
        if (root == null)
            return false;
        Node now = root;
        Node father = null;
        boolean isFatherLeft = true;  // 记录now结点是father的左孩子还是右孩子
        Stack<Node> toUpdate = new Stack<>();  // 记录在删除操作后需要更新的结点
        while (now != null) {
            toUpdate.push(now);
            if (val < now.val) {
                father = now;
                isFatherLeft = true;
                now = now.leftChild;
            } else if (val > now.val) {
                father = now;
                isFatherLeft = false;
                now = now.rightChild;
            } else {
                toUpdate.pop();
                if (now.leftChild == null && now.rightChild == null) {
                    // 情况一：待删除结点没有左右孩子，直接删除即可
                    if (father == null) {
                        root = null;
                    } else if (isFatherLeft) {
                        father.leftChild = null;
                    } else {
                        father.rightChild = null;
                    }
                } else if (now.leftChild != null && now.rightChild == null) {
                    // 情况二：待删除结点只有左孩子，则将该左孩子连接到父结点上即可
                    if (father == null) {
                        root = now.leftChild;
                    } else if (isFatherLeft) {
                        father.leftChild = now.leftChild;
                    } else {
                        father.rightChild = now.leftChild;
                    }
                } else if (now.leftChild == null && now.rightChild != null) {
                    // 情况三：待删除结点只有右孩子，则将该右孩子连接到父结点上即可
                    if (father == null) {
                        root = now.rightChild;
                    } else if (isFatherLeft) {
                        father.leftChild = now.rightChild;
                    } else {
                        father.rightChild = now.rightChild;
                    }
                } else {
                    // 情况四：待删除结点有左右孩子，则：
                    // 1. 找到该结点的右结点x
                    // 2. 一直向左，找到x最左边的左结点y
                    // 3. 将待删除结点的值改为y的值
                    // 4. 按情况三的思路删除y
                    toUpdate.push(now);
                    Node cur = now.rightChild;
                    Node _father = null;
                    while (cur.leftChild != null) {
                        toUpdate.push(cur);
                        _father = cur;
                        cur = cur.leftChild;
                    }
                    now.val = cur.val;
                    if (_father != null) {
                        _father.leftChild = cur.rightChild;
                    } else {
                        now.rightChild = cur.rightChild;
                    }
                }
                // 删除操作完毕后，更新祖先结点
                while (!toUpdate.empty()) {
                    toUpdate.pop().update();
                }
                return true;
            }
        }
        return false;
    }

    // 清空容器
    public void clear() {
        root = null;
    }

    // 获取结点总数
    public int size() {
        if (root == null) {
            return 0;
        } else {
            return root.cnt;
        }
    }

    // 获取val的排名
    // val的排名定义为比val小的数的个数+1
    public int rank(int val) {
        Node cur = root;
        int _rank = 1;
        while (cur != null) {
            if (val <= cur.val) {
                cur = cur.leftChild;
            } else {
                _rank += nodeRank(cur);
                cur = cur.rightChild;
            }
        }
        return _rank;
    }

    // 获取排名为k的元素
    // 返回值为-1表示元素不存在
    public int kth(int rk) {
        Node cur = root;
        while (cur != null) {
            int _rank = nodeRank(cur);
            if (rk < _rank) {
                cur = cur.leftChild;
            } else if (rk > _rank) {
                rk -= _rank;
                cur = cur.rightChild;
            } else {
                return cur.val;
            }
        }
        return -1;
    }

    // 检测容器是否包含某个值
    public boolean contains(int val) {
        Node cur = root;
        while (cur != null) {
            if (val < cur.val) {
                cur = cur.leftChild;
            } else if (val > cur.val) {
                cur = cur.rightChild;
            } else {
                return true;
            }
        }
        return false;
    }

    // 返回val的前驱
    // val的前驱定义为小于val且最大的数
    public int lower(int val) {
        return kth(rank(val) - 1);
    }

    // 返回val的后继
    // val的后继定义为大于val且最小的数
    public int upper(int val) {
        return kth(rank(val + 1));
    }
}

功能验证

为了验证以上代码的正确性，笔者还编写了一个验题程序，能够产生随机数，对容器进行随机操作，并校验结果的正确性。

package BalancedTree.BST;

import java.util.*;

public class Test {
    static final int ROUND = 200;  // 测试轮数
    static final int UPPER_BOUND = 200;  // 往容器中添加的元素的最大值
    static final int MAX_SIZE = 500;  // 当容器尺寸超过阈值时，结束测试
    static final int QUERY_TIME = 10;  // 查询排名的次数

    List<Integer> list;
    Tree tree;
    Random random;

    Test(Tree tree) {
        this.tree = tree;
        list = new LinkedList<>();
        random = new Random();
    }

    void list_insert(int val) {
        ListIterator<Integer> iter = list.listIterator();
        while (iter.hasNext()) {
            int _val = iter.next();
            if (val <= _val) {
                iter.previous();
                break;
            }
        }
        iter.add(val);
    }

    int list_rank(int val) {
        ListIterator<Integer> iter = list.listIterator();
        int rank = 1;
        while (iter.hasNext()) {
            int _val = iter.next();
            if (_val >= val) {
                break;
            }
            ++rank;
        }
        return rank;
    }

    void test_insert() {
        int val = random.nextInt(UPPER_BOUND);
        list_insert(val);
        tree.insert(val);
        test_size();
    }

    void test_size() {
        if (tree.size() != list.size()) {
            throw new Error("两个容器的size不一致！");
        }
    }

    void test_remove() {
        Integer val = random.nextInt(UPPER_BOUND);
        if (list.remove(val) != tree.remove(val)) {
            throw new Error("remove()的实现有问题！");
        }
        test_size();
    }

    void test_rank() {
        for (int i = 0; i < QUERY_TIME; ++i) {
            int val = random.nextInt(UPPER_BOUND);
            if (list_rank(val) != tree.rank(val)) {
                throw new Error("rank()的实现有问题！");
            }
        }
    }

    void test_kth() {
        for (int i = 0; i < QUERY_TIME; ++i) {
            int size = list.size();
            int rank = random.nextInt(size * 3 + 1) - size;
            int val;
            if (rank >= 1 && rank <= list.size()) {
                val = list.get(rank - 1);
            } else {
                val = -1;
            }
            if (tree.kth(rank) != val) {
                throw new Error("kth()的实现有问题！");
            }
        }
    }

    void test_contains() {
        for (int i = 0; i < QUERY_TIME; ++i) {
            int val = random.nextInt(UPPER_BOUND);
            if (tree.contains(val) != list.contains(val)) {
                throw new Error("contains()的实现有问题！");
            }
        }
    }

    void test_lower() {
        for (int i = 0; i < QUERY_TIME; ++i) {
            int val = random.nextInt(UPPER_BOUND);
            Iterator<Integer> iter = ((LinkedList<Integer>) list).descendingIterator();
            int lower = -1;
            while (iter.hasNext()) {
                int _val = iter.next();
                if (_val < val) {
                    lower = _val;
                    break;
                }
            }
            if (tree.lower(val) != lower) {
                throw new Error("lower()的实现有问题！");
            }
        }
    }

    void test_upper() {
        for (int i = 0; i < QUERY_TIME; ++i) {
            int val = random.nextInt(UPPER_BOUND);
            int upper = -1;
            for (int num : list) {
                if (num > val) {
                    upper = num;
                    break;
                }
            }
            if (tree.upper(val) != upper) {
                throw new Error("upper()的实现有问题！");
            }
        }
    }

    void test() {
        Random random = new Random();
        for (int round = 0; round < ROUND; ++round) {
            list.clear();
            tree.clear();
            if (list.size() != tree.size()) {
                throw new Error("clear()的实现有问题！");
            }
            while (list.size() <= MAX_SIZE) {
                int op = random.nextInt(8) + 1;
                if (op == 1) {
                    test_insert();
                } else if (op == 2) {
                    test_remove();
                } else if (op == 3) {
                    test_rank();
                } else if (op == 4) {
                    test_kth();
                } else if (op == 5) {
                    test_upper();
                } else if (op == 6) {
                    test_lower();
                } else if (op == 7) {
                    test_size();
                } else if (op == 8) {
                    test_contains();
                } else {
                    throw new Error("op设置有误！");
                }
            }
            test_size();
        }
        System.out.println("测试完毕，没有发现错误！");
    }

    public static void main(String[] args) {
        new Test(new ScapegoatTree()).test();
    }
}
犇犇~
关注
专栏目录
二叉搜索树BST的实现（一）
KANEKI的博客
03-22 198
二叉搜索树BST的实现 翻博客的时候突然发现，我原来已经有一年多没有写过博客了，懒得不行，最近要开始找工作才发现自己有好多地方欠缺，准备查漏补缺了，多写博客激励自己，不要再懒下去了 很久没有用过指针，有些生疏了 BST 二叉搜索树有下列三个特点： 左子树的值都小于根的值 右子树的值都大于根的值 对于每一个结点，它的左右子树分别又是一个二叉搜索树 根据上述的特点，可以构造出一个包含三个数据对象的...
TreeSWT:利用SWT来图形化显示二叉树 目前支持二叉查找树BST
05-11
`TreeSWT`项目正是一款利用`SWT`（Standard Widget Toolkit）库来实现二叉树图形化的工具，特别针对二叉查找树（Binary Search Tree, BST）进行了优化支持。本文将深入探讨`TreeSWT`的实现原理、功能以及如何在...
数据结构：二叉搜索树（BST）的基本操作
weixin_30682127的博客
12-21 308
概述： 学习过数据结构的童鞋都应该知道，对树的操作是一些最基本的技能（本文是对后面要写B树、B-树、B+树的一个前导，已经熟悉的朋友可以跳过了）。而在树结构中，二叉树又是最基础的。虽然这些知识是比较基础的，不过对于BST的操作中，删除是一个相对比较麻烦的。这对于新手来说可能不太好理解，下面就以BST中节点的删除为主，其他操作为辅的策略来编写本篇文章。希望对你能有所帮助。 本文链接：...
BST二叉查找树
slience_646898的博客
07-15 462
二叉查找树，也称二叉搜索树或二叉排序树，其有如下的性质：   若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值 任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值 任意节点的左、右子树也分别为二叉查找树 没有键值相等的节点 基于二分的思想，二叉查找树的优势在于其查找、搜索的时间复杂度低为O(logN)，中序遍历输出的结果是单...
（BST）二叉搜索树的操作（一）
bitlxlx的博客
04-21 301
概念： 二叉搜索树：又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树 1、若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 2、若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 3、它的左右子树也分别为二叉搜索树 /* * 说明1：这篇博客介绍的是二叉搜索树所有操作（除了删除）的非递归写法。 *下一篇博客介绍，二叉搜索树的递归写法，和删除操作。 *
浅析树结构（一）二叉查找树(BST树代码实现)
tubro2017的博客
01-08 244
二叉查找树 二叉查找树定义 定义:一颗二叉查找树(BST)是一棵二叉树,其中每个结点都含有一个Comparable的键(以及相关联的值)且每个结点的键都大于其左子树中的任意结点的键而小于右子树的任意结点的键. 二叉查找树中搜索,插入,删除的复杂度等于树高，即O(log(n)) 二叉查找树代码实现 基本方法实现 import java.util.ArrayList; import java.u...
二叉查找树BST，可以看看
12-13
二叉查找树（Binary Search Tree，简称BST），是一种特殊的二叉树数据结构，它具有以下特性：对于树中的任意一个节点，其左子树中所有节点的值都小于该节点的值，而右子树中所有节点的值都大于该节点的值。...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
二叉查找树（BST）和折半查找（C语言实现）
最新发布
qq_62225979的博客
11-14 1414
二叉查找树（BST）的实现，以及和折半查找的性能比较。数据结构作业（C语言实现）
c 打印二叉树_考研数据结构算法之二叉树
weixin_39601657的博客
11-24 126
查找二叉树值为x的结点。// 查找二叉树中值为x的结点 求二叉树的高度int 打印二叉树void 输出叶子结点void 先序遍历非递归算法// 算法思想1 二叉树的层次遍历// 层次遍历 编写在以BST为树根指针的二叉搜索树上进行查找值为item的结点的非递归算法，若查找成功能则由item带回整个结点的值并返回true,否则返回false.函数原型bool Find(BTreeNode *BST,...
700. 二叉搜索树中的搜索
weixin_40764894的博客
06-03 116
算法题（程序员面试宝典） 解题思路主要来源于leetcode官方与《程序员面试宝典》。 700. 二叉搜索树中的搜索 给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。 例如， 给定二叉搜索树: 4 / \ 2 7 / \ 1 3 和值: 2 你应该返回如下子树: 2 / \ 1 3 在上述示例中，如果要找的值是 5，但因为没有节点值为 5，我们应该返
查找BST中Kth小的元素
martin_liang的专栏
03-19 796
Node* findKthSmallNode(Node *pNode, int &Kth) { if (!pNode) return NULL; Node* pRetNode = NULL; pRetNode = findKthSmallNode(pNode->left, Kth); if (pRetNode != NULL) re
二叉排序树（BST）查找算法详解之C语言版
sunnyoldboy博客
10-04 3670
在二叉排序树上查找某个结点，其实就是遍历二叉树。由于二叉排序树上的结点是有序的，因此不需要使用普通二叉树的遍历算法，其有自己一套简单的遍历算法，即从树根开始进行遍历，如果待查找元素小于树根元素，则向左遍历，否则向右遍历，如果相等结束遍历。
二叉排序树（BST查找、插入、删除、遍历）——基于树的查找（一）
热门推荐
weixin_39651041的博客
04-21 1万+
二叉排序树 二叉排序树（Binary Search Tree，BST）：又称二叉查找树，是一种高效的数据结构。 定义 二叉排序树或者是一棵空树，或者是具有如下特性的二叉树： 若左子树不空，则左子树上所有结点的值均小于或等于根结点的值； 若右子树不空，则右子树上所有结点的值均大于或等于根结点的值； 左、右子树也分别为二叉排序树 如下便是一棵二叉排序树 根据定义，再根据二叉树中...
详解二叉搜索树(BinarySearchTree)
鱼儿往上游的博客
06-24 911
I 二叉搜索树特点 每个结点有唯一的值，且每个结点的值均不相同； 若它的左子树不为空，则它的左子树的所有结点均小于根节点的值； 若它的右子树不为空，则它的右子树的所有结点均大于根结点的值； 它的左右子树均为二叉搜索树。 II 二叉搜索树的操作 二叉查找树由节点组成，所以需要一个 Node 类 public class Node { public int Data; public Node left; public Node right; public void.
图论 - 割点（Tarjan）
耿鸭的幸福生活
07-29 1558
文章目录定义例题 定义 在一个无向图中，如果有一个顶点集合，删除这个顶点集合以及这个集合中所有顶点相关联的边以后，图的连通分量增多，就称这个点集为割点集合。 如果某个割点集合只含有一个顶点X（也即{X}是一个割点集合），那么X称为一个割点。 如果图是连通的，那么割点的定义就是，在一个无向连通图中，如果删除某个顶点后，图不再连通，则这个顶点为割点。 通过Tarjan算法可以求出所有割点，时间复杂度为O(N + M)。 例题 洛谷P3388 给定一个无向图（不一定连通），求出所有割点。 #include &lt
字符串 - 判断子序列
耿鸭的幸福生活
07-27 1483
定义 假如字符串 s 是 t 的子序列，那么可以删除 t 中的一些字符（也可以不删除），使得剩下的字符按原来的顺序排列得到的字符串等于s。 代码 LeetCode 392 代码比较简单，故不加赘述，记录本帖的意义在于防止日后卡壳。 时间复杂度：O(N + M)，N和M为两个字符串的长度。 #include <iostream> #include <vector> #include <cstdio> #include <string> #include <
数学 - 线性基
耿鸭的幸福生活
07-26 523
定义 线性基是向量空间的一组基，通常可以解决有关异或的一些题目。 通俗一点的讲法就是由一个集合构造出来的另一个集合，它有以下几个性质： 线性基的元素能 相互异或 得到原集合的元素的所有 相互异或 得到的值。 线性基是满足性质 1 的最小的集合。 线性基没有异或和为 0 的子集。 线性基中每个元素的异或方案唯一，也就是说，线性基中不同的异或组合异或出的数都是不一样的。 线性基中每个元素的二进制最高位互不相同。 线性基的构造方法： 对原集合的每个数 x 转为二进制，从高位向低位扫描，对于第 i 位是 1 的
二叉查找树（BST）详解与Python实现
二叉查找树（Binary Search Tree，BST），作为一种重要的数据结构，它在计算机科学中扮演着关键角色，特别是在数据存储和检索方面。这种树的每个节点最多有两个子节点——左子节点和右子节点。二叉查找树的主要特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值