二叉排序树——BST（java）

最新推荐文章于 2023-04-11 00:10:15 发布
最新推荐文章于 2023-04-11 00:10:15 发布
阅读量469 收藏 8
点赞数 2
分类专栏： 数据结构 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_41304904/article/details/105825274
版权
本文介绍了二叉排序树（BST）的基本概念、优点，通过图解展示了如何建立BST。详细阐述了向BST中添加节点、中序遍历及删除节点的思路和代码实现，包括如何处理叶子节点、寻找父节点、删除操作的复杂情况。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

概念分析

二叉排序树：对于二叉排序树的任何一个非叶子节点，要求左子结点的值比当前结点的值要小，右子结点的值比当前结点的值要大。如果有相同的值，可以将该结点放在左子结点或者右子结点。
注：下文中所有BST均代表二叉排序树（BinarySortTree）

优点

首先查找的快，我们进行查找时，只需要比较比当前结点小还是大，之后去对应的左右子树进行查询就好。
添加也很快，最多需要比较树的深度次，之后插入进去即可。

图解

我们将数组{7, 3, 10, 12, 5, 1, 9, 2}依次添加进BST中。
在这里插入图片描述

建立一个BST
叶子节点
class BinarySortTreeNode{
	int value;
    BinarySortTreeNode left;
    BinarySortTreeNode right;

    public BinarySortTreeNode(int value){
        this.value = value;
    }
 	/**
     * BST中序遍历
     */
    public void inorderTraversal(){
        if (this.left != null){
            this.left.inorderTraversal();
        }
        System.out.print(this.value + "\t");
        if (this.right != null){
            this.right.inorderTraversal();
        }
    }

    @Override
    public String toString() {
        return "BinarySortTreeNode{" +
                "value=" + value +
                '}';
    }
}
BST
public class BinarySortTree {
    BinarySortTreeNode root;
}
向BST中添加节点
思路分析
  1. 当BST为空，将BST的root结点赋值为待添加结点即可
  2. 若BST不为空，比较其与根结点的值，小的话向左添加，大的话向右，之后再比较其与根节点的左子结点或者右子结点的值，这一步取决于与根节点的大小比较，之后如果下面还有结点，那就一路递归向下比较，最后将其添加使其成为一个叶子结点
代码实现
// 通过叶子结点实现add方法
	/**
     * BST添加节点
     * @param node 待添加的节点
     */
    public void add(BinarySortTreeNode node){
        if(node == null){
            return;
        }
        // 添加的节点小于此节点的值 我们将其添加到左子结点处
        if (node.value < this.value){
            if (this.left == null){
                this.left = node;
            }else {
                // 如果其左子结点不为空，那么我们将要插入的节点与其左子结点进行比较
                this.left.add(node);
            }
        }else { // 相等的或者大于的都添加到右子结点
            if (this.right == null){
                this.right = node;
            }else {
                this.right.add(node);
            }
        }
    }
  
// 通过BST调用结点类的add方法
 	/**
     * BST添加节点
     * @param node 待被添加的节点
     */
    public void add(BinarySortTreeNode node){
        if (root == null) {
            root = node;
        }else {
            root.add(node);
        }
    }
BST遍历
思路分析

遍历的思路与二叉树一样，但是由于BST的性质，我们一般采用中序遍历，因为中序遍历出来的数据是有序的（因为其左边结点的值小于自身，右边结点的值又大于自身）

代码实现
// 结点类的遍历
 /**
     * BST中序遍历
     */
    public void inorderTraversal(){
        if (this.left != null){
            this.left.inorderTraversal();
        }
        System.out.print(this.value + "\t");
        if (this.right != null){
            this.right.inorderTraversal();
        }
    }

// BST的遍历
    /**
     * BST实现中序遍历
     */
    public void inorderTraversal(){
        if (root == null){
            System.out.println("BST为空");
        }else {
            root.inorderTraversal();
        }
    }
BST删除节点
思路分析

删除节点是比较复杂的，因为我们要保证删除过后依然是一个BST，所以需要在删除时进行很多判断

  1. 如果该BST只有一个根节点，那么将根节点置空，终止流程
  2. 找到要被删除的节点，没找到则终止流程
  3. 因为二叉树是单向的，所以我们还需要找到其父结点
  4. 判断待删除节点是否是叶子节点（判断其是否有左子结点和右子结点）
  5. 如果是叶子节点，那么我们将其父结点对应的位置置为空即可，比如，待删除结点是其父结点的左子结点，那么就是parent.left = null，若是右子结点，那么parent.right = null
  6. 如果不是叶子节点，我们还需要判断其只有一个子树还是有两个子树
  7. 如果只有一个子树，那么我们进行判断待删除节点是其父结点的左子结点还是右子结点
  8. 如果是其父结点的左子结点，那么parent.left = targetNode.child(待删除节点那个唯一的子树)
  9. 如果是右子结点，那么只需要parent.right= targetNode.child(待删除节点那个唯一的子树)
  10. 如果待删除节点的子树有两个，这时我们将其删除，还需要找到它的左子树中最大的值放到待删除结点的位置，或者右子树中最小的值放到待删除结点的位置。这时将你选择的左边最小或者右边最大的结点删除即可
    解释： 第10步为什么这么做呢？ 我们顺着分析一下，如果删除当前结点，其有左子树和右子树，我们将该结点删除后，需要补一个比其左子树都大的值并且比其右子树都小的值放到被删除的结点的位置上。而左子树的所有值都小于右子树的最小值，右子树的所有值都大于左子树的最大值，所以我们随便从左子树取一个最大值，之后将其删除，放到待删除结点的位置，或者从右子树中取最小值放过来（这一步相当于我先换位置，之后把左边最大或者右边最小删除），这样删除后仍然是一个BST。
查找待删除的节点
/**
     * 查找待删除的节点
     * @param value 待删除节点的值
     * @return 返回被删除的节点 不存在该节点则返回null
     */
    public BinarySortTreeNode search(int value){
        if(this.value == value){
            return this;
        } else if (value < this.value){ // 二叉排序树的左子结点都小于其父结点的值
            if (this.left == null){
                return  null;
            }else {
                return this.left.search(value);
            }
        }else { // 如果不小于其父结点的值 那么可以判断在右子结点
            if (this.right == null){
                return  null;
            }else {
                return this.right.search(value);
            }
        }
    }
查找待删除节点的父结点
/**
     * 查找待删除节点的父结点
     * @param value 待删除节点的值
     * @return 待删除节点的父结点
     */
    public BinarySortTreeNode searchParent(int value){
        if((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)){
            return this;
        } else {
            if (value < this.value && this.left != null){
                return this.left.searchParent(value);
            } else if (value >= this.value && this.right != null){
                return this.right.searchParent(value);
            }else {
                return null;
            }
        }
    }
找到左子树最大的值并删除
   public int deleteLeftMax(BinarySortTreeNode node){
        BinarySortTreeNode temp = node;
        while (temp.right != null){
            temp = temp.right;
        }
        // 找到左侧最大 将其删除
        temp = delete(temp.value);
        return temp.value;
    }
找到右子树最小的值并删除
public int deleteRightMin(BinarySortTreeNode node){
        BinarySortTreeNode temp = node;
        while (temp.left != null){
            temp = temp.left;
        }
        // 找到右侧最小 将其删除
        temp = delete(temp.value);
        return temp.value;
    }
删除的方法
public BinarySortTreeNode delete(int value){
        // 如果当前BST为空 直接结束流程 返回空
        if (root == null){
            return null;
        } else {
            // 1. 先去找到待删除的节点
            BinarySortTreeNode targetNode = search(value);
            // 没有找到待删除节点
            if (targetNode == null){
                return null;
            }
            // 如果可以找到待删除节点 并且BST只有一个root
            if (root.left == null && root.right == null){
                BinarySortTreeNode temp = root;
                root = null;
                return temp;
            }
            // 如果可以找到待删除节点 并且BST不只有一个root，那么待删除节点必然有父结点
            BinarySortTreeNode parent = searchParent(value);
            // 判断待删除节点是否是叶子节点
            if(targetNode.left == null && targetNode.right == null){
                if (parent.left != null &&parent.left.value == value){
                    BinarySortTreeNode temp = parent.left;
                    parent.left = null;
                    return temp;
                } else if (parent.right != null && parent.right.value == value){
                    BinarySortTreeNode temp = parent.right;
                    parent.right = null;
                    return temp;
                }else {
                    return null;
                }
            }else if (targetNode.left != null && targetNode.right != null){
                // 这种情况是待删除节点有两个子结点
                int target;
//                target = deleteRightMin(targetNode.right);
                target = deleteLeftMax(targetNode.left);
                targetNode.value = target;
            }else {
                // 待删除节点只有一个子结点
                // 待删除节点的子结点是左子结点
                if(targetNode.left != null){
                    if (parent != null){
                        if (parent.left.value == value){
                            parent.left = targetNode.left;
                        }else {
                            parent.right = targetNode.left;
                        }
                    }else {
                        root = targetNode.left;
                    }

                }else {
                    if (parent != null){
                        if (parent.left.value == value){
                            parent.left = targetNode.right;
                        }else {
                            parent.right = targetNode.right;
                        }
                    }else {
                        root = targetNode.right;
                    }
                }
                return targetNode;
            }
            return null;
        }
    }
全部代码
package com.nansl.binaryTree;

public class BinarySortTree {
    BinarySortTreeNode root;

    public static void main(String[] args) {
        int[] arr = {7, 3, 10, 12, 5, 1, 9, 2};
        BinarySortTree tree = new BinarySortTree();
        for (int i = 0; i < arr.length; i++){
            BinarySortTreeNode node = new BinarySortTreeNode(arr[i]);
            tree.add(node);
        }
        tree.delete(2);
        tree.delete(5);
        tree.delete(9);
        tree.delete(12);
        tree.delete(7);
        tree.delete(3);
        tree.delete(10);
//        tree.delete(1);
        tree.inorderTraversal();
    }

    /**
     * 找到左子树中最大的值
     * @param node 左子树的根节点
     * @return 返回左子树中最大的值
     */
    public int deleteLeftMax(BinarySortTreeNode node){
        BinarySortTreeNode temp = node;
        while (temp.right != null){
            temp = temp.right;
        }
        // 找到左侧最大 将其删除
        temp = delete(temp.value);
        return temp.value;
    }

    /**
     * 找到右子树中最小的值
     * @param node 右子树的根节点
     * @return 返回右子树中最小的值
     */
    public int deleteRightMin(BinarySortTreeNode node){
        BinarySortTreeNode temp = node;
        while (temp.left != null){
            temp = temp.left;
        }
        // 找到右侧最小 将其删除
        temp = delete(temp.value);
        return temp.value;
    }

    public BinarySortTreeNode delete(int value){
        // 如果当前BST为空 直接结束流程 返回空
        if (root == null){
            return null;
        } else {
            // 1. 先去找到待删除的节点
            BinarySortTreeNode targetNode = search(value);
            // 没有找到待删除节点
            if (targetNode == null){
                return null;
            }
            // 如果可以找到待删除节点 并且BST只有一个root
            if (root.left == null && root.right == null){
                BinarySortTreeNode temp = root;
                root = null;
                return temp;
            }
            // 如果可以找到待删除节点 并且BST不只有一个root，那么待删除节点必然有父结点
            BinarySortTreeNode parent = searchParent(value);
            // 判断待删除节点是否是叶子节点
            if(targetNode.left == null && targetNode.right == null){
                if (parent.left != null &&parent.left.value == value){
                    BinarySortTreeNode temp = parent.left;
                    parent.left = null;
                    return temp;
                } else if (parent.right != null && parent.right.value == value){
                    BinarySortTreeNode temp = parent.right;
                    parent.right = null;
                    return temp;
                }else {
                    return null;
                }
            }else if (targetNode.left != null && targetNode.right != null){
                // 这种情况是待删除节点有两个子结点
                int target;
//                target = deleteRightMin(targetNode.right);
                target = deleteLeftMax(targetNode.left);
                targetNode.value = target;
            }else {
                // 待删除节点只有一个子结点
                // 待删除节点的子结点是左子结点
                if(targetNode.left != null){
                    if (parent != null){
                        if (parent.left.value == value){
                            parent.left = targetNode.left;
                        }else {
                            parent.right = targetNode.left;
                        }
                    }else {
                        root = targetNode.left;
                    }

                }else {
                    if (parent != null){
                        if (parent.left.value == value){
                            parent.left = targetNode.right;
                        }else {
                            parent.right = targetNode.right;
                        }
                    }else {
                        root = targetNode.right;
                    }
                }
                return targetNode;
            }
            return null;
        }
    }

    public BinarySortTreeNode search(int value){
        if (root == null){
            return null;
        }else {
            return root.search(value);
        }
    }

    public BinarySortTreeNode searchParent(int value){
        if (root == null){
            return  null;
        }else {
            return root.searchParent(value);
        }
    }
    /**
     * BST添加节点
     * @param node 待被添加的节点
     */
    public void add(BinarySortTreeNode node){
        if (root == null) {
            root = node;
        }else {
            root.add(node);
        }
    }

    /**
     * BST实现中序遍历
     */
    public void inorderTraversal(){
        if (root == null){
            System.out.println("BST为空");
        }else {
            root.inorderTraversal();
        }
    }

}
class BinarySortTreeNode{
    int value;
    BinarySortTreeNode left;
    BinarySortTreeNode right;

    public BinarySortTreeNode(int value){
        this.value = value;
    }

    /**
     * 查找待删除的节点
     * @param value 待删除节点的值
     * @return 返回被删除的节点 不存在该节点则返回null
     */
    public BinarySortTreeNode search(int value){
        if(this.value == value){
            return this;
        } else if (value < this.value){ // 二叉排序树的左子结点都小于其父结点的值
            if (this.left == null){
                return  null;
            }else {
                return this.left.search(value);
            }
        }else { // 如果不小于其父结点的值 那么可以判断在右子结点
            if (this.right == null){
                return  null;
            }else {
                return this.right.search(value);
            }
        }
    }

    /**
     * 查找待删除节点的父结点
     * @param value 待删除节点的值
     * @return 待删除节点的父结点
     */
    public BinarySortTreeNode searchParent(int value){
        if((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)){
            return this;
        } else {
            if (value < this.value && this.left != null){
                return this.left.searchParent(value);
            } else if (value >= this.value && this.right != null){
                return this.right.searchParent(value);
            }else {
                return null;
            }
        }
    }

    /**
     * BST添加节点
     * @param node 待添加的节点
     */
    public void add(BinarySortTreeNode node){
        if(node == null){
            return;
        }
        // 添加的节点小于此节点的值 我们将其添加到左子结点处
        if (node.value < this.value){
            if (this.left == null){
                this.left = node;
            }else {
                // 如果其左子结点不为空，那么我们将要插入的节点与其左子结点进行比较
                this.left.add(node);
            }
        }else { // 相等的或者大于的都添加到右子结点
            if (this.right == null){
                this.right = node;
            }else {
                this.right.add(node);
            }
        }
    }

    /**
     * BST中序遍历
     */
    public void inorderTraversal(){
        if (this.left != null){
            this.left.inorderTraversal();
        }
        System.out.print(this.value + "\t");
        if (this.right != null){
            this.right.inorderTraversal();
        }
    }

    @Override
    public String toString() {
        return "BinarySortTreeNode{" +
                "value=" + value +
                '}';
    }
}

坚持只为更好的风景。

二叉查找树BST----java实现
毛毛虫的小哈
08-07 1万+
二叉查找树BST----java实现 1.二叉查找树简介 二叉查找树又名二叉搜索树和二叉排序树。性质如下：   在二叉查找树中： (01) 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； (02) 任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； (03) 任意节点的左、右子树也分别为二叉查找树。 (04) 没有键值相等的节点（no dupl
数据结构（十三）——二叉排序树
North_City_的博客
08-20 809
二叉排序树（BST）: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点， 要求左子节点的值比当前节点的值小， 右子节点的值比当前节点的值大。 特别说明： 如果有相同的值， 可以将该节点放在左子节点或右子节点 比如针对数据 (7, 3, 10, 12, 5, 1, 9) ， 对应的二叉排序树为： 二叉排序树的建立与遍历 package binarysorttreee; public class BinarySortTreeDemo { public stat
BST(Java)
weixin_46943250的博客
07-15 225
如上图构建BST。 为BST实现以下功能： Height，PreOrder，PostOrder，InOrder，Tree_MinimumRecursive，Tree_MaximumIterative public class MainTest { public static void main(String[] args) { TreeNode root = new MainTest().buildTree(); new MainTest().preOrder(root); //new.
bst java_BST（二叉搜索树） Java 实现解析
weixin_30111277的博客
02-18 298
1.二叉搜索树的定义：一颗树的所有左子树都比根小，所有右子树都比根大，成为二叉搜索树。2.该BST树实现了9个重要方法，分别是关键字查找，插入，删除，删除节点后续节点查找，前序遍历，中序遍历，后序遍历，获取最大节点，获取最小节点。3.以下是Java的代码实现：//定义Node类，拥有元素值，节点名称，左孩子节点，右孩子节点，4个成员变量。class Node {int element;String...
Java实现BST（二叉查找树）
jing___jing的专栏
07-26 682
实现不全，以后再补充 package binaryTree; import dictionaryADT.Dictionary; public class BST implements Dictionary{ private BinNode root; private int nodecount; public BST() { root =null; nodecount
Java数据结构---BST（二叉搜索树）
cloud的博客
08-06 434
文章目录1. List简介2. LinkedList基础操作3. ArrayList基础操作 1. List简介 List是Java中的一种数据结构。 Collection的接口如下图所示。其中List的接口有ArrayList和LinkedList，分别表示顺序表和链表。 2. LinkedList 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表。 基础操作 创建链表 //
Java 树结构实际应用 三（二叉排序树）（csdn）————程序.pdf
12-01
二叉排序树，也称为二叉搜索树（Binary Sort Tree 或 Binary Search Tree，BST），是一种特殊的二叉树数据结构。它具有以下特性： 1. **节点性质**：对于树中的任意节点，其左子树中的所有节点值都小于该节点值，而...
二叉排序树java代码,能直接运行且有代码注释
02-11
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或有序二叉树，是一种自平衡的二叉树数据结构。它在处理大量数据时具有高效性，特别是对于插入、删除和查找操作。在二叉排序树中，每个节点的左子树中的所有...
数据结构 综合性实验 实现二叉排序树的各种算法功能 有源码 有实验报告
09-05
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉排序树（Binary Sort Tree，BST），这是一种特殊的二叉树，具有高效的查找、插入和删除操作。二叉排序树的特性是左子树上的所有节点的值都小于根节点，...
数据结构与算法 赫夫曼与BST二叉排序树
qq_43198052的博客
09-11 347
赫夫曼 基本介绍 1) 给定 n 个权值作为 n 个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree), 还有的书翻译为霍夫曼树。 2) 赫夫曼树是带权路径长度最短的树，权值较大的结点离根较近 赫夫曼树几个重要概念和举例说明 1) 路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为 1，则从根结点到第 L 层结点的路径长度
Java之二叉搜索树(BST)
qq_64580912的博客
04-11 1757
（Binary Search Tree，简称因为二叉搜索树具有上述的性质，所以可以等操作。在二叉搜索树中，一个元素的，其中n是树中节点的个数。同时，在二叉搜索树中，可以按照某种顺序（如）输出树中的所有节点，因此也可以作为一种的方法。
Java数据结构之二分搜索树(BST)
qq15035899256的博客
08-05 793
本文是Java数据结构的学习，认识了BST树，BST树的插入和删除操作，以及BST树的不平衡性。之后的学习内容将持续更新！！！
java手写BST
我的博客
10-01 422
难易程度：★★★ 重要性：★★★★★ 今日头条的面试中有过要求：手写实现BST import java.util.*; public class MyBSTImpl { // BST中的节点 TreeNode root; static class TreeNode { int val; TreeNode left;...
Java学习——数据结构——BST二叉排序树
qq_41853002的博客
05-29 206
学习尚硅谷韩顺平老师的Java数据结构笔记，详情请移步网站 1、需求 给你一个数列 (7, 3, 10, 12, 5, 1, 9)，要求能够高效的完成对数据的查询和添加。 2、解决方案分析 2.1 使用数组 数组未排序， 优点：直接在数组尾添加，速度快。 缺点：查找速度慢. 数组排序，优点：可以使用二分查找，查找速度快，缺点：为了保证数组有序，在添加新数据时，找到插入位置后，后面的数据需整体移动，速度慢。 2.2 使用链式存储-链表 不管链表是否有序，查找速度都慢，添加数据速度比数组快，不需要数据整体移动。
Java实现 二叉搜索树算法（BST）
cloud-2014的专栏
07-20 664
http://www.importnew.com/20754.html 一、树 & 二叉树 树是由节点和边构成，储存元素的集合。节点分根节点、父节点和子节点的概念。 如图：树深=4; 5是根节点；同样8与3的关系是父子节点关系。 二叉树binary tree，则加了“二叉”（binary），意思是在树中作区分。每个节点至多有两个子（child）,left child
java创建bst树_JAVA生成BST（二叉查找树）树
weixin_30884379的博客
02-27 236
public class BST> {public Node root; //二叉树的根节点private class Node{private Key key; //键private Node left,right; //指向子树的连接public Node(Key key){this.key = key;}}public void insertRec(Key k...
详解二叉搜索树(BST)的Java实现和五种遍历方式，移动智能终端开发技术第三次作业
m0_54852680的博客
01-19 251
//记作当前节点 TreeNode current = root; //current为null，跳出循环，parent节点代表我们要插入元素的父节点 while (current != null) { //如果我们要插入的节点小于当前节点，就去遍历其左子树 //否则遍历右子树 if (o.compareTo(current.element) < 0) { parent = current; current = current.left; } else if (o.compareTo(current.
BST student类 java
weixin_46943250的博客
07-15 218
1. Implement a BST of students using Insert function. The information of a student includes id, name, and major. 2. Search the BST given the name of a student. 3. Find the successor/predecessor of a given student node. public class BTS { public static v.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值