学习笔记：《程序员小灰》二叉查找树（Binary Search Tree）

最新推荐文章于 2022-03-18 20:52:54 发布
最新推荐文章于 2022-03-18 20:52:54 发布
阅读量291 收藏 2
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57488641/article/details/115978006
版权

文章目录

1 定义

二叉查找树（Binary Search Tree）的特征：

  • 若左子树不空，则左子树上所有节点的值均小于或等于它的根节点的值；
  • 若右子树不空，则右子树上所有节点的值均大于或等于它的根节点的值；
  • 左、右子树也分别为二叉查找树。

在这里插入图片描述

2 查找

将要查找的数据与根节点的值进行比较，如果相等就返回，如果小于就到左子树中递归查找，如果大于就到右子树中递归查找。

在这里插入图片描述

3 添加

在二叉查找树中进行插入操作时只需找到待插入的父节点，将数据插入即可。

在这里插入图片描述

4 删除

  • 在待删除的节点没有子节点时，直接删除该节点，即在其父节点中将其对应的子节点置空即可。

在这里插入图片描述

  • 在待删除的节点只有一个子节点时，使用子节点替换当前节点，然后删除该节点即可。

在这里插入图片描述

  • 在待删除的节点有两个子节点时，首先查找该节点的替换节点（两种做法：左子树中的最大节点、右子树中的最小节点），然后替换待删除的节点为替换节点，最后删除替换节点。

在这里插入图片描述

5 存在的问题

倘若二叉查找树多次在同一侧插入节点，将会导致性能变差，几乎变成线性查找。

在这里插入图片描述

6 实现

定义二叉查找树节点：

/**
 * 二叉查找树节点
 *
 * @author wgm
 * @since 2021/4/25
 */
public class BinarySearchTreeNode {

    private Integer data;
    private BinarySearchTreeNode leftChild;
    private BinarySearchTreeNode rightChild;

    public BinarySearchTreeNode(Integer data) {
        this.data = data;
    }

    public BinarySearchTreeNode setLeftChild(int data) {
        BinarySearchTreeNode node = new BinarySearchTreeNode(data);
        this.setLeftChild(node);
        return node;
    }

    public BinarySearchTreeNode setRightChild(int data) {
        BinarySearchTreeNode node = new BinarySearchTreeNode(data);
        this.setRightChild(node);
        return node;
    }

    @Override
    public String toString() {
        return data.toString();
    }

    public Integer getData() {
        return data;
    }

    public void setData(Integer data) {
        this.data = data;
    }

    public BinarySearchTreeNode getLeftChild() {
        return leftChild;
    }

    public void setLeftChild(BinarySearchTreeNode leftChild) {
        this.leftChild = leftChild;
    }

    public BinarySearchTreeNode getRightChild() {
        return rightChild;
    }

    public void setRightChild(BinarySearchTreeNode rightChild) {
        this.rightChild = rightChild;
    }
}

定义二叉查找树：

import java.util.LinkedList;

/**
 * 二叉查找树
 *
 * @author wgm
 * @since 2021/4/25
 */
public class BinarySearchTree {

    private BinarySearchTreeNode root;

    public BinarySearchTree(BinarySearchTreeNode root) {
        this.root = root;
    }

    /**
     * 建树
     *
     * @param ints
     * @return
     */
    public static BinarySearchTree buildTree(int[] ints) {
        if (ints == null || ints.length == 0) {
            return null;
        }
        BinarySearchTree tree = new BinarySearchTree(new BinarySearchTreeNode(ints[0]));
        for (int i = 1; i < ints.length; i++) {
            tree.insert(ints[i]);
        }
        return tree;
    }

    /**
     * 查找节点是否存在
     *
     * @param data
     * @return
     */
    public boolean exist(int data) {
        if (this.root == null) {
            return false;
        }
        BinarySearchTreeNode visit = root;
        while (visit != null) {
            if (data < visit.getData()) {
                visit = visit.getLeftChild();
            } else if (data > visit.getData()) {
                visit = visit.getRightChild();
            } else {
                return true;
            }
        }
        return false;
    }

    /**
     * 添加节点
     *
     * @param data
     */
    public void insert(int data) {
        if (this.root == null) {
            return;
        }
        BinarySearchTreeNode preVisit = root;
        BinarySearchTreeNode visit = root;
        while (visit != null) {
            preVisit = visit;
            if (data <= visit.getData()) {
                visit = visit.getLeftChild();
            } else {
                visit = visit.getRightChild();
            }
        }
        if (data <= preVisit.getData()) {
            preVisit.setLeftChild(data);
        } else {
            preVisit.setRightChild(data);
        }
    }

    /**
     * 删除节点
     *
     * @param data
     */
    public void delete(int data) {
        if (this.root == null) {
            return;
        }
        BinarySearchTreeNode preVisit = root;
        BinarySearchTreeNode visit = root;
        while (visit != null) {
            if (data < visit.getData()) {
                preVisit = visit;
                visit = visit.getLeftChild();
            } else if (data > visit.getData()) {
                preVisit = visit;
                visit = visit.getRightChild();
            } else {
                delete(preVisit, visit);
                break;
            }
        }
    }

    private void delete(BinarySearchTreeNode preVisit, BinarySearchTreeNode visit) {
        BinarySearchTreeNode leftChild = visit.getLeftChild();
        BinarySearchTreeNode rightChild = visit.getRightChild();
        if (leftChild == null && rightChild == null) { // 待删除节点为叶子节点
            if (visit.getData() < preVisit.getData()) { // 待删除节点为父节点的左节点
                preVisit.setLeftChild(null);
            } else if (visit.getData() > preVisit.getData()) { // 待删除节点为父节点的右节点
                preVisit.setRightChild(null);
            } else { // 待删除节点为根节点
                root = null;
            }
        } else if (leftChild != null && rightChild == null) { // 待删除节点只有左节点
            if (visit.getData() < preVisit.getData()) { // 待删除节点为父节点的左节点
                preVisit.setLeftChild(leftChild);
            } else if (visit.getData() > preVisit.getData()) { // 待删除节点为父节点的右节点
                preVisit.setRightChild(leftChild);
            } else { // 待删除节点为根节点
                root = leftChild;
            }
        } else if (leftChild == null && rightChild != null) { // 待删除节点只有右节点
            if (visit.getData() < preVisit.getData()) { // 待删除节点为父节点的左节点
                preVisit.setLeftChild(rightChild);
            } else if (visit.getData() > preVisit.getData()) { // 待删除节点为父节点的右节点
                preVisit.setRightChild(rightChild);
            } else { // 待删除节点为根节点
                root = rightChild;
            }
        } else { // 待删除节点有左、右节点
            BinarySearchTreeNode ppre = leftChild;
            BinarySearchTreeNode p = leftChild;
            while (p.getRightChild() != null) {
                ppre = p;
                p = p.getRightChild();
            }

            ppre.setRightChild(null);
            if (visit.getLeftChild() != p) {
                p.setLeftChild(visit.getLeftChild());
            }
            p.setRightChild(visit.getRightChild());
            visit.setLeftChild(null);
            visit.setRightChild(null);

            if (visit.getData() < preVisit.getData()) { // 待删除节点为父节点的左节点
                preVisit.setLeftChild(p);
            } else if (visit.getData() > preVisit.getData()) { // 待删除节点为父节点的右节点
                preVisit.setRightChild(p);
            } else { // 待删除节点为根节点
                root = p;
            }
        }
    }

    /**
     * 层序遍历（队列）
     */
    public void level() {
        if (this.root == null) {
            return;
        }
        BinarySearchTreeNode visit = this.root;
        LinkedList<BinarySearchTreeNode> queue = new LinkedList<>();
        queue.offer(visit);
        while (!queue.isEmpty()) {
            visit = queue.poll();
            System.out.print(visit + " ");
            BinarySearchTreeNode leftChild = visit.getLeftChild();
            if (leftChild != null) {
                queue.offer(leftChild);
            }
            BinarySearchTreeNode rightChild = visit.getRightChild();
            if (rightChild != null) {
                queue.offer(rightChild);
            }
        }
        System.out.println();
    }

    @Override
    public String toString() {
        return "BinarySearchTree{" +
                "root=" + root +
                '}';
    }

    public BinarySearchTreeNode getRoot() {
        return root;
    }

    public void setRoot(BinarySearchTreeNode root) {
        this.root = root;
    }
}

编写测试类：

import java.util.Arrays;

/**
 * 二叉查找树测试
 *
 * @author wgm
 * @since 2021/4/25
 */
public class BinarySearchTreeTest {

    public static void main(String[] args) {
        int[] ints = new int[] {10, 4, 5, 2, 12, 14, 8};

        BinarySearchTree tree = BinarySearchTree.buildTree(ints);
        tree.level();
        System.out.println("节点11是否存在：" + tree.exist(11));
        System.out.println("节点12是否存在：" + tree.exist(12));

        System.out.println("\r\n循环添加元素");
        for (int i = 0; i < ints.length; i++) {
            if (i == 0) {
                tree = BinarySearchTree.buildTree(Arrays.copyOfRange(ints, 0, 1));
                tree.level();
            } else {
                tree.insert(ints[i]);
                tree.level();
            }
        }

        System.out.println("\r\n循环删除元素");
        for (int i = 0; i < ints.length; i++) {
            tree.level();
            tree.delete(ints[i]);
        }
    }
}

7 测试

D:\program\Java\jdk1.8.0_241\bin\java.exe -agentlib:jdwp=transport=dt_socket,address=127.0.0.1:59009,suspend=y,server=n "-javaagent:C:\Users\GMWANG~1\AppData\Local\Temp\captureAgent172jars\debugger-agent.jar" -Dfile.encoding=UTF-8 -classpath "D:\program\Java\jdk1.8.0_241\jre\lib\charsets.jar;D:\program\Java\jdk1.8.0_241\jre\lib\deploy.jar;D:\program\Java\jdk1.8.0_241\jre\lib\ext\access-bridge-64.jar;D:\program\Java\jdk1.8.0_241\jre\lib\ext\cldrdata.jar;D:\program\Java\jdk1.8.0_241\jre\lib\ext\dnsns.jar;D:\program\Java\jdk1.8.0_241\jre\lib\ext\jaccess.jar;D:\program\Java\jdk1.8.0_241\jre\lib\ext\jfxrt.jar;D:\program\Java\jdk1.8.0_241\jre\lib\ext\localedata.jar;D:\program\Java\jdk1.8.0_241\jre\lib\ext\nashorn.jar;D:\program\Java\jdk1.8.0_241\jre\lib\ext\sunec.jar;D:\program\Java\jdk1.8.0_241\jre\lib\ext\sunjce_provider.jar;D:\program\Java\jdk1.8.0_241\jre\lib\ext\sunmscapi.jar;D:\program\Java\jdk1.8.0_241\jre\lib\ext\sunpkcs11.jar;D:\program\Java\jdk1.8.0_241\jre\lib\ext\zipfs.jar;D:\program\Java\jdk1.8.0_241\jre\lib\javaws.jar;D:\program\Java\jdk1.8.0_241\jre\lib\jce.jar;D:\program\Java\jdk1.8.0_241\jre\lib\jfr.jar;D:\program\Java\jdk1.8.0_241\jre\lib\jfxswt.jar;D:\program\Java\jdk1.8.0_241\jre\lib\jsse.jar;D:\program\Java\jdk1.8.0_241\jre\lib\management-agent.jar;D:\program\Java\jdk1.8.0_241\jre\lib\plugin.jar;D:\program\Java\jdk1.8.0_241\jre\lib\resources.jar;D:\program\Java\jdk1.8.0_241\jre\lib\rt.jar;D:\project\untitled\out\production\untitled;D:\program\JetBrains\IntelliJ IDEA 2020.1\lib\idea_rt.jar" BinarySearchTreeTest
Connected to the target VM, address: '127.0.0.1:59009', transport: 'socket'
10 4 12 2 5 14 8 
节点11是否存在：false
节点12是否存在：true

循环添加元素
10 
10 4 
10 4 5 
10 4 2 5 
10 4 12 2 5 
10 4 12 2 5 14 
10 4 12 2 5 14 8 

循环删除元素
10 4 12 2 5 14 8 
8 4 12 2 5 14 
8 2 12 5 14 
8 2 12 14 
8 12 14 
8 14 
8 
Disconnected from the target VM, address: '127.0.0.1:59009', transport: 'socket'

Process finished with exit code 0
人类自救指南
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
漫画算法-小灰的算法之旅-树（三）
YETA的博客
06-13 2761
1.树 2.二叉树 2.1 满二叉树 2.2 完全二叉树 3.二叉树的应用 3.1查找 3.2维持相对顺序（插入） 4.二叉树的遍历 5.二叉堆 6.优先队列 1.树 树是n个节点的有限集。当n=0时，称为空树。在任意一个非空树中，有如下特点： 有且仅有一个特定的称为根的节点； 当n>1时，其余节点可分为m个互不相交的有限集，每一个集合本身又...
学习笔记：《程序员小灰》平衡二叉树（AVL Tree）
边行动边改善
04-23 187
漫画：什么是AVL树？（修订版） 定义： 对于AVL树的每一个结点，平衡因子是它的左子树高度和右子树高度的差值。只有当二叉树所有结点的平衡因子都是-1, 0, 1这三个值的时候，这颗二叉树才是一颗合格的AVL树。 AVL树的左旋、右旋 AVL树的左旋、右旋与红黑树相同。 AVL树的添加、删除 1. 左左局面（LL） 自平衡：右旋。 2. 左右局面（LR） 自平衡：左旋->右旋。 ...
二叉查找树（Binary Search Tree）
gaofen100
08-05 158
二叉查找树（Binary Search Tree），或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 二叉查找树的表示： class Node { int data; Node leftChil...
一文高效图解二叉树面试题
程序员小灰的博客
05-16 835
本文转载自公众号 码出高效面试的程序媛二叉树，搜索二叉树，是算法面试的必面题。聊聊面试点：一、树 & 二叉树树的组成为节点和边，节点用来储存元素。节点组成为根节点...
剑指offer——二叉搜索树的第k个节点
一个程序媛的成长记录❤
03-09 276
题目描述 给定一棵二叉搜索树，请找出其中的第k小的TreeNode结点。 关于二叉搜索树： 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文
BST.rar_binary search tree_二叉搜索树
09-19
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点，其左子树中的所有...
JS中的算法与数据结构之二叉查找树（Binary Sort Tree）实例详解
10-16
二叉查找树（Binary Sort Tree，BST）是数据结构中的一种特殊树形结构，它具有以下特点：每个节点都有一个键值，且左子树中所有节点的键值小于当前节点，右子树中所有节点的键值大于当前节点。这种特性使得二叉查找...
Binary_Search_Tree:用Java实现的二叉搜索树
06-08
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点，其左子树中的所有...
avl.rar_AVL树_binary search tree
09-24
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL，AV是两位发明者名字的首字母。在AVL树中，任何节点的两个子树的高度最大差别不...
二叉查找树python二叉查找树源码
最新发布
11-22
二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是一种特殊的二叉树数据结构。它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉查找树中，对于...
Java二叉搜索树实现
weixin_30908941的博客
04-29 291
树集合了数组（查找速度快）和链表（插入、删除速度快）的优点 二叉树是一种特殊的树，即：树中的每个节点最多只能有两个子节点 二叉搜索树是一种特殊的二叉树，即：节点的左子节点的值都小于这个节点的值，节点的右子节点的值都大于等于这个节点的值 节点类： public class Node { public int id; public String name; public Node...
学习笔记：《程序员小灰》二叉堆（Binary Heap）
边行动边改善
04-24 331
漫画：什么是二叉堆？（修正版） 定义 二叉堆（Binary Heap）本质上是一种完全二叉树，它分为：最大堆、最小堆。 二叉堆的特征： 最大堆：任何一个父节点的值，都大于等于它左右孩子节点的值。 最小堆：任何一个父节点的值，都小于等于它左右孩子节点的值。 添加 删除 构建 所有节点，依次上浮，或依次下沉。 应用 堆排序、优先级队列。 实现 import java.util.Arrays; /** * 二叉堆 * <p> * 大顶堆 * * @author wgm *
Binary search tree
u011712857的专栏
08-22 421
#include #include using std::cin; using std::cout; using std::endl; using std::vector; template struct BinaryNode { Type num; struct BinaryNode *llink; struct BinaryNode *rlink; typedef Binary
Java实现：二叉搜索树(Binary Search Tree)，突围金九银十面试季
m0_63174529的博客
11-11 126
/** 节点 @param */ private static class BinaryNode { BinaryNode(AnyType theElement) { this(theElement, null, null); } BinaryNode(AnyType theElement, BinaryNode left, BinaryNode right) { element = theElement; left = left; right = right; } AnyType elem
数据结构 -- 二叉查找树（Binary Search Tree）
qq_41814874的博客
02-04 601
二叉查找树（Binary Search Tree），也称二叉搜索树，二叉排序树。定义如下： 要么是一颗空树； 要么就是具有如下性质的二叉树： （1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3） 任意节点的左、右子树也分别为二叉查找树； （4） 没有键值相等的节点。 二叉搜索...
【数据结构05】红-黑树基础----二叉搜索树（Binary Search Tree）
宜春
12-13 2261
至于博主为何要花一整篇文章来讲这个二叉搜索树呢？原因很简单，红-黑树是基于二叉搜索树的，如果对二叉搜索树不了解，那还谈何红-黑树？红-黑树的重要性我想各位没吃过佩奇肉也肯定看过宜春跑....首先要明确的是二叉搜索树又称二叉排序树、二叉查找树，简统称BST。在正式将二叉搜索树之前，宜春还是想先谈谈人生谈谈生活从而切入二叉搜索树。 一天，程序员老方给宜春打电话：靓仔，我今天下单了一双皮鞋，老靓了，价格不菲啊！ 宜春：得了吧你，啥条件啊我还不知道，还皮鞋，老鼠皮的鞋吧，如果是真牛皮的皮鞋我把它吃喽！！！
《玩转数据结构 从入门到进阶》二分搜索树 Binary Search Tree
CodingSoldier的博客
08-06 287
本文来源于liuyubobobo的“玩转数据结构 从入门到进阶”视频教程 上图是一个Binary Search Tree，因汉字数量庞大，就有了很多种翻译，如：二分搜索树、二叉搜索树、…………… 二分搜索树以二叉树为基础，但多了两个特点: 1、二分搜索树节点的值具有可比较性。 2、每个节点都比它左子树的任意元素大，而且比右子树的任意元素小（此文不讨论有重复元素的树）。 下面使用jav...
【小白爬Leetcode315】6.4 （搜索二叉树版）计算右侧小于当前元素的个数 Count of Smaller Numbers After Self
weixin_41604040的博客
07-18 193
【小白爬Leetcode315】6.4（搜索二叉树版） 计算右侧小于当前元素的个数 Count of Smaller Numbers After Self题目Discription中文解释思路一 归并排序+pair绑定原序数：思路二 搜索二叉树 Binary Search Tree Leetcode 315 hard\color{#FF0000}{hard}hard 点击进入原题链接：Leetcode 315 计算右侧小于当前元素的个数 Count of Smaller Numbers After Se
二分搜索树（Binary Search Tree）
小孙的博客
03-18 1692
本身是二叉树，只不过对于二分搜索树的每一个结点而言 大于其左子树的所有结点的值 小于其右子树的所有结点的值 同样，其子树也是一颗二分搜索树 那么该树中的元素要具有可比性不包含重复元素 ...
数据结构实验七-查找.docx
07-11
一、二叉排序树（Binary Search Tree, BST） 二叉排序树是一种特殊的二叉树，每个节点的左子树只包含小于当前节点值的节点，右子树包含大于当前节点值的节点。这种结构使得在树中进行查找操作变得非常高效，平均时间...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值