二叉搜索树详解（附代码）

最新推荐文章于 2024-06-08 16:32:22 发布
最新推荐文章于 2024-06-08 16:32:22 发布
阅读量1.2w 收藏 13
点赞数 7
分类专栏： 算法数据结构 # Java 文章标签： java BST
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37684467/article/details/119549267
版权

今天讲一下二叉搜索树

文章目录

1. 定义

这里我们引用百度百科的解释：

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树：

  1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
  3. 它的左、右子树也分别为二叉排序树。

二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。

2. BST数据结构的实现

这里采用Java语言实现。

2.1. 数据结构定义

BST结点类

class BSTNode<T extends Comparable<T>> {
        T data;
        BSTNode<T> left;
        BSTNode<T> right;

        public BSTNode(T data) {
            this.data = data;
        }
}

BST实现类

public class BST<T extends Comparable<T>> {
  	/**
     * BST的根结点
     */
    private BSTNode<T> root;

	// put,remove find等方法
}

2.2. 实现增删查询操作

2.2.1. 添加元素

待添加元素值value，
有两条规则：

  1. 如果此时根结点为空，则new一个结点，赋值给根结点
  2. 根结点不为空，则需要为当前元素找一个合适的位置（保证插入以后，整棵树还是BST），将其插入。
    在这里插入图片描述

代码如下：

    /**
     * 添加元素到BST
     * @param value 待添加的元素
     * @return 添加是否成功 成功--true，失败 false
     */
    public boolean put(T value) {
        // 不允许null值
        if (value != null) {

            //根结点为空，则新加入的元素作为根
            if (root == null) {
                root = new BSTNode<>(value);
            } else {
                // 否则，找到一个合适的位置
                // p记录当前结点的父结点
                BSTNode<T> p = null, cur = root;
                while (cur != null) {
                    p = cur;
                    // 如果有相同元素，则不插入
                    if (cur.data.compareTo(value) == 0) return false;
                    //如果value 小于当前元素 则cur跳到左子树 否则 跳到右子树
                    if (value.compareTo(cur.data) < 0) cur = cur.left;
                    else cur = cur.right;
                }
                //上面的while退出后，cur是null，p抓到cur的父结点
                BSTNode<T> node = new BSTNode<>(value);
                //如果value小于p的值，则挂在p的左子树，否则挂在右子树
                if (value.compareTo(p.data) < 0) p.left = node;
                else p.right = node;
            }
            return true;
        }
        return false;
    }

2.2.2. 查找元素

待添加元素值value，
有两条规则：

  1. 如果此时根结点为空，返回没找到
  2. 根结点不为空，则判断根结点的值是否等于value，是则返回，否则如果根结点值大于value，则跑到根的左子树继续寻找，否则跑到右子树继续寻找。如果在中途没有返回，则返回没找到。
    在这里插入图片描述
    代码如下：
    /**
     * 查找元素
     * @param value 待查找的元素
     * @return 找到返回true，否则false
     */
    public boolean find(T value) {
        //根为空，直接返回没找到
        if (root == null) return false;
        //根给当前结点
        BSTNode<T> cur = root;
        //只要cur不为空，则一直寻找
        while (cur != null) {
            //如果相等，则找到返回
            if (cur.data.compareTo(value) == 0) return true;
            //如果value比当前结点小，则跑到左子树继续找，否则到右子树继续找
            if (value.compareTo(cur.data) < 0) cur = cur.left;
            else cur = cur.right;
        }
        //中途没返回，则没找到
        return false;
    }

2.2.3. 删除元素

删除元素稍微麻烦一些，首先找到删除的结点，找不到则返回，啥都不做，如果找到，记为node，我们要保证删除了node结点以后，整棵树还是BST，如何保证呢？我们知道，BST的中序遍历结果是一个排序的序列，因此删除某个元素node时，如果：

  1. node的左右子树都是空，则直接删除，让指向它的父结点指向空即可；
  2. node左右子树至少一个不为空，我们需要找到在中序遍历中，node的前驱结点或后继节点来替代它的位置。
    1. 如果node的左子树为空，那就使用node的右子树顶替node的位置
    2. 否则，如果node的右子树为空，那就使用node的左子树顶替node的位置
    3. 否则，即左右子树都不是空，我们可以在左子树上找一个“最右的结点”，或在右子树上找一个“最左”的结点，顶替node的位置
      在这里插入图片描述

代码如下：

    /**
     * 删除结点value
     * @param value 待删除的结点
     * @return 删除成功返回true，否则返回false
     */
    public boolean remove(T value) {
        //根为空，啥也没有，删除个啥？ 直接返回
        if (root == null) return false;

        //下面的while循环主要目的是找出待删除的结点，同时找到它的父节点p
        BSTNode<T> p = null, cur = root;
        while (cur != null) {
            //如果找到 则退出循环
            if (cur.data.compareTo(value) == 0) break;

            //否则，p抓住当时的cur，即为cur的父节点，cur根据情况 跳左还是跳右
            p = cur;
            if (value.compareTo(cur.data) < 0) cur = cur.left;
            else cur = cur.right;
        }

        //这说明没找到待删除的结点，直接返回
        if (cur == null) return false;

        //如果左cur左子树为空，则使用其右子树顶替它，指向cur的父结点指向其右子树
        if(cur.left==null){
            // p是空 代表，cur是根结点，则直接替换根
            if(p==null)root = cur.right;
            else {// 否则 更新其父结点的指向
                if(p.left==cur)p.left = cur.right;
                else p.right = cur.right;
            }
        }else if(cur.right==null){ //如果左cur右子树为空，则使用其左子树顶替它，指向cur的父结点指向其左子树
            if(p==null)root = cur.left;
            else {
                if(p.left==cur)p.left = cur.left;
                else p.right = cur.left;
            }
        }else {
            // cur左右子树都存在的情况，这里我使用找其右子树最左结点的方式
            // next结点就是其右子树最左结点，parent是其父结点
            BSTNode<T> parent = cur,next = cur.right;
            //只要next的left不是null，则next就不是最左结点，next跳其左节点，继续
            while (next.left!=null){
                parent = next;//在next跳下一个之前，先抓一下，使得parent始终指向其父结点
                next = next.left;
            }

            //把右子树最左结点和树的父节点断开，其父节点指向next的右子树，
            if(next==parent.left)parent.left = next.right;

            //next有可能是parent的右结点，即有可能cur.right根本就没有左子树，则cur.right本身就是要找的结点
            else parent.right = next.right;
            
            //把右子树最左结点的值，赋值给要删除的结点即可完成替换。
            cur.data = next.data;
        }
        return true;
    }

在这里插入图片描述

3. 测试

完整代码如下，测试程序已写好，大家有兴趣可以测试

package com.victory.common.data_structure;

import java.util.Scanner;

/**
 * 二叉搜索树
 */
public class BST<T extends Comparable<T>> {

    /**
     * BST的根结点
     */
    private BSTNode<T> root;

    /**
     * 添加元素到BST
     * @param value 待添加的元素
     * @return 添加是否成功 成功--true，失败 false
     */
    public boolean put(T value) {
        // 不允许null值
        if (value != null) {

            //根结点为空，则新加入的元素作为根
            if (root == null) {
                root = new BSTNode<>(value);
            } else {
                // 否则，找到一个合适的位置
                // p记录当前结点的父结点
                BSTNode<T> p = null, cur = root;
                while (cur != null) {
                    p = cur;
                    // 如果有相同元素，则不插入
                    if (cur.data.compareTo(value) == 0) return false;
                    //如果value 小于当前元素 则cur跳到左子树 否则 跳到右子树
                    if (value.compareTo(cur.data) < 0) cur = cur.left;
                    else cur = cur.right;
                }
                //上面的while退出后，cur是null，p抓到cur的父结点
                BSTNode<T> node = new BSTNode<>(value);
                //如果value小于p的值，则挂在p的左子树，否则挂在右子树
                if (value.compareTo(p.data) < 0) p.left = node;
                else p.right = node;
            }
            return true;
        }
        return false;
    }

    /**
     * 查找元素
     * @param value 待查找的元素
     * @return 找到返回true，否则false
     */
    public boolean find(T value) {
        //根为空，直接返回没找到
        if (root == null) return false;
        //根给当前结点
        BSTNode<T> cur = root;
        //只要cur不为空，则一直寻找
        while (cur != null) {
            //如果相等，则找到返回
            if (cur.data.compareTo(value) == 0) return true;
            //如果比当前结点小，则跑到左子树继续找，否则到右子树继续找
            if (value.compareTo(cur.data) < 0) cur = cur.left;
            else cur = cur.right;
        }
        //中途没返回，则没找到
        return false;
    }

    /**
     * 删除结点value
     * @param value 待删除的结点
     * @return 删除成功返回true，否则返回false
     */
    public boolean remove(T value) {
        //根为空，啥也没有，删除个啥？ 直接返回
        if (root == null) return false;

        //下面的while循环主要目的是找出待删除的结点，同时找到它的父节点p
        BSTNode<T> p = null, cur = root;
        while (cur != null) {
            //如果找到 则退出循环
            if (cur.data.compareTo(value) == 0) break;

            //否则，p抓住当时的cur，即为cur的父节点，cur根据情况 跳左还是跳右
            p = cur;
            if (value.compareTo(cur.data) < 0) cur = cur.left;
            else cur = cur.right;
        }

        //这说明没找到待删除的结点，直接返回
        if (cur == null) return false;

        //如果左cur左子树为空，则使用其右子树顶替它，指向cur的父结点指向其右子树
        if(cur.left==null){
            // p是空 代表，cur是根结点，则直接替换根
            if(p==null)root = cur.right;
            else {// 否则 更新其父结点的指向
                if(p.left==cur)p.left = cur.right;
                else p.right = cur.right;
            }
        }else if(cur.right==null){ //如果左cur右子树为空，则使用其左子树顶替它，指向cur的父结点指向其左子树
            if(p==null)root = cur.left;
            else {
                if(p.left==cur)p.left = cur.left;
                else p.right = cur.left;
            }
        }else {
            // cur左右子树都存在的情况，这里我使用找其右子树最左结点的方式
            // next结点就是其右子树最左结点，parent是其父结点
            BSTNode<T> parent = cur,next = cur.right;
            //只要next的left不是null，则next就不是最左结点，next跳其左节点，继续
            while (next.left!=null){
                parent = next;//在next跳下一个之前，先抓一下，使得parent始终指向其父结点
                next = next.left;
            }

            //把右子树最左结点和树的父节点断开，其父节点指向next的右子树，
            if(next==parent.left)parent.left = next.right;

            //next有可能是parent的右结点，即有可能cur.right根本就没有左子树，则cur.right本身就是要找的结点
            else parent.right = next.right;

            //把右子树最左结点的值，赋值给要删除的结点即可完成替换。
            cur.data = next.data;
        }
        return true;
    }

    public void inOrder(){
        inOrder(root);
    }

    private void inOrder(BSTNode<T> node){
        if(node!=null){
            inOrder(node.left);
            System.out.print(" ");
            System.out.print(node.data);
            System.out.print(" ");
            inOrder(node.right);
        }
    }

    private static class BSTNode<T extends Comparable<T>> {
        T data;
        BSTNode<T> left;
        BSTNode<T> right;

        public BSTNode(T data) {
            this.data = data;
        }
    }

    public static void main(String[] args) {
        BST<Integer> integerBST = new BST<>();
        Scanner sc = new Scanner(System.in);
        while (true){
            String command = sc.next();
            if("exit".equals(command))break;
            if("put".equals(command)){
                int n = sc.nextInt();
                if(integerBST.put(n)) System.out.println(n+" 添加成功");
                else System.out.println(n+" 添加失败");
            }
            if("find".equals(command)){
                int n = sc.nextInt();
                if(integerBST.find(n)) System.out.println(n+" 存在BST中");
                else System.out.println(n+" 不存在BST中");
            }
            if("remove".equals(command)){
                int n = sc.nextInt();
                if(integerBST.remove(n)) System.out.println(n+" 删除成功");
                else System.out.println(n+" 删除失败");
            }
            if("print".equals(command)){
                integerBST.inOrder();
            }
        }
    }

}

码字仓促，如发现有错误，请大家不吝赐教，觉得文章不错的话，给个支持吧 ^_^

张凯1
关注
  • 7
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
（一）BST树（二叉搜索树）
qq_42119136的博客
06-29 4971
（一）BST树（二叉搜索树） 1.BST二叉搜索树 1.1BST树的定义 1 BST树也是一个二叉树，故满足递归定义; 2 其次每个节点只存在一个值; 3 需满足左子树值<=根值<=右子树，故按照中序遍历会得到一个非递减序列。 BST涉及操作主要增，删，查，除了删麻烦一点，其他操作均可递归实现，二叉查找树的一般性质： 1.在一棵二叉查找树上，执行查找、插入、删除等操作，的时间复杂度为O（log2n）。因为，一棵由n个结点，随机构造的二叉查找树的高度为log2n，所以顺理成章，一般操作的执行时间为
数据结构与算法详解——二叉查找树篇（附c++实现代码）
JMasker的博客
05-23 1370
目录二叉树相关概念和术语二叉树特殊类型二叉树的存储链式存储顺序存储二叉树的遍历二叉查找树查找插入删除完整代码 二叉树相关概念和术语   二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 度：一个节点拥有子树的数目称为结点的度，叶子结点的度为0。 叶子结点：也称为终端结点，没有子树的结点或者度为零的结点。 结点的层次：从根结点开始，假设根结点为第1层，根节点的子结点为第2层，依此类推，如果某一个结点位于第L
数据结构，二叉搜索树的详解
我的主页
04-24 675
本期讲解：二叉搜索树是怎样形成的，怎样查找二叉搜索树的结点，插入结点以及删除结点。
二叉搜索树(二叉排序树)
热门推荐
爱敲代码的三毛的博客
09-09 4万+
一.概念 二叉搜索树又称二叉排序树，具有以下性质： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 注意：二叉搜索树中序遍历的结果是有序的 二、基本操作 1.查找元素 思路：二叉搜索树的左子树永远是比根节点小的，而它的右子树则都是比根节点大的值。当前节点比要找的大就往左走，当前元素比要找的小就往右走 public Node search(int key) { if(root ==
二叉查找树详解
最新发布
m0_72674633的博客
06-08 1056
二叉查找树详解
10.二叉搜索树完整代码
程序员阿红的博客
02-10 655
Person类： package dataStruct.tree.binarySearchTree; public class Person { private int age; public Person(int age){ this.age = age; } // @Override // public int compareTo(Person p) { // return age - p.age; // } p
Java二叉搜索树基础原理与实现方法详解
08-19
Java二叉搜索树基础原理与实现方法详解 本文详细介绍了Java二叉搜索树的基础原理与实现方法，涵盖了二叉树的定义、特点、二叉搜索树的定义、性质、思想、编程实现等方面的知识点。 一、树的定义 树是n（n>=0）个...
bst_二叉搜索树_
09-29
**二叉搜索树（Binary Search Tree，BST）详解** 二叉搜索树是一种特殊的二叉树结构，它具有以下特性： 1. **每个节点的左子树仅包含比该节点小的元素。** 2. **每个节点的右子树仅包含比该节点大的元素。** 3. **...
二叉排序树详解.zip
05-29
二叉排序树，又称二叉查找树或二叉有序树，是计算机科学中一种非常重要的数据结构，尤其在处理搜索和排序操作时。它是一种特殊的二叉树，满足以下两个关键性质： 1. **左子树特性**：对于任意节点，其左子树中的...
C语言 二叉查找树性质详解及实例代码
08-31
C语言二叉查找树性质详解及实例代码 二叉查找树是一种特殊的二叉树，它的每个节点最多有两个子节点，左子树和右子树。二叉查找树的性质是：一个节点的所有左子树上的节点不大于该节点，所有右子树的节点不小于该...
java 二叉查找树实例代码
08-31
Java 二叉查找树实例代码详解 Java 二叉查找树是一种特殊的二叉树，它的左子树的所有节点值小于根节点值，右子树的所有节点值大于根节点值。这种树结构使得查找、插入、删除操作的时间复杂度都降低到了O(log n)。...
Binary Search Tree code 二叉检索树代码
04-21
是Binary Search Tree code 二叉检索树的代码，实现了插入，删除，检索，遍历，包括先序遍历，中序遍历，后序遍历
数据结构-二叉排序树（BST树）
理科男同学
11-15 9478
1，二叉排序树介绍 二叉排序树（Binary Sort Tree）或者是一颗空树；或者是具有如下性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树又分别为二叉排序树。 显然二叉排序树的定义是一个递归形式的定义，所以后面景禹要讲的插入、查找和删除都是基于递归的形式。特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点 1.1，二叉排序树的构建 假设我们有初始的无序...
二叉搜索树详解与实现
a1912157861的博客
01-09 601
二叉搜索树详解与实现二叉搜索树概念二叉树的增删查改K类型二叉搜索树和KV类型二叉搜索树的底层代码实现 二叉搜索树概念 二叉搜索树又称二叉排序树，它具有以下这几种性质: 如果它的左子树不为空，则左子树上所有节点的值都小于根节点的值 如果它的右子树不为空，则右子树上所有节点的值都大于根节点的值 他的左右子树都是二叉搜索树 那么它为什么要叫做二叉排序树呢？ 因为它的中序遍历就是一个有序的数列，所以我们一般用中序遍历来遍历二叉搜索树，并且也可以使用二叉搜索树的这个特性来检查当前二叉树是否是二叉搜索树。 二叉树的
数据结构-二叉搜索树 详解
HeartFireY的博客
06-06 2328
一、二叉搜索树 简介 二叉搜索树(BST, Binary Search Tree)是一种基于二叉树的树形数据结构，定义(满足的性质)如下 空树是二叉搜索树 若二叉搜索树的左子树不为空，则其左子树上所有点的权值均小于其根节点的权值； 若二叉搜索树的右子树不为空，则其右子树上所有点的权值均大于其根节点的权值； 二叉搜索树的左右子树均为二叉搜索树 不难发现，二叉搜索树是采用递归进行定
搜索二叉树基本功能实现（源代码）
fangfang_666的博客
10-23 536
功能实现已经介绍过了详见：http://blog.csdn.net/fangfang_666/article/details/52904520 源代码： #include #include using namespace std; template struct BinarySearchNode { BinarySearchNode * _left; BinarySearchNode *
二叉搜索树（BST）分析及实现
S5242的博客
05-17 1721
二叉搜索树（BST）的概念，以及插入删除操作分析和实现。
《算法导论》之最优二叉搜索树
sunshine_lyn的博客
09-20 1万+
最优二叉搜索树 假定我们正在设计一个程序，实现英语文本到法语的翻译。对英语文本中出现的每个单词，我们需要查找对应的法语单词。为了实现这些查找操作，可以创建一棵二叉搜索树，将n个英语单词作为关键字，对应的法语单词作为关联数据。由于文本中的每个单词都要进行搜索，我们希望花费在搜索上的总时间尽量少。 通过红黑树或其他平衡搜索树结构，我们可以假定每次搜索时间为O(lgn) 。但由于单词出现的频率是不同的，...
【算法学习】最优二叉查找树（动态规划）
chuanzhuanxian8669的博客
06-15 2453
一、什么是最优二叉查找树 最优二叉查找树： 给定n个互异的关键字组成的序列K=<k1,k2,...,kn>，且关键字有序（k1<k2<...<kn），我们想从这些关键字中构造一棵二叉查找树。对每个关键字ki，一次搜索搜索到的概率为pi。可能有一些搜索的值不在K...
二叉搜索树的删除代码详解
04-19
好的，我可以回答关于二叉搜索树的问题。二叉搜索树是一种常见的数据结构，可以用于快速查找、插入、删除数据。对于删除节点的操作，需要分为三种情况进行处理，分别是删除叶子节点、删除只有一个子节点的节点、删除...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值