二叉搜索树的构造（Java实现）

最新推荐文章于 2024-09-18 19:31:33 发布
最新推荐文章于 2024-09-18 19:31:33 发布
阅读量3.4k 收藏 17
点赞数 3
分类专栏： 数据结构 文章标签： java 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48455576/article/details/122547253
版权

目录

一、什么是二叉搜索树

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。
来源：百度百科_二叉搜索树

图片来源于菜鸟教程

二、二叉搜索树的性质

  1. 二叉搜索树本质也是一棵二叉树
  2. 每个根节点的值大于其左子树所有节点的值
  3. 每个根节点的值小于其右子树所有节点的值
  4. 每一课子树都是一棵二叉搜索树
  5. 存储的元素必须具有可比较性

三、二叉搜索树的构造

1. 构造基本的二叉搜索树

/**
 * @author Dream_飞翔
 * @date 2022/1/17
 * @time 20:16
 * @email 1072876976@qq.com
 */
public class BST<E extends Comparable<E>> {
    // 声明二分搜索树的节点类
    private class Node {
        // 存放节点值的变量
        public E e;
        // 指向左子树和右子树的变量
        public Node left, right;

        public Node (E e) {
            this.e = e;
            // 将左子树和右子树初始化为空
            left = null;
            right = null;
        }
    }

    // 二分搜索树的根节点
    private Node root;
    // 当前二分搜索树存储的元素的个数
    private int size;

    public BST() {
        // 初始化时二分搜索树根节点为空
        root = null;
        // 存储了0个元素
        size = 0;
    }

    // 获取当前二分搜索树存储元素个数的方法
    public int size() {
        return size;
    }

    // 判断当前二分搜索树是否为空
    public boolean isEmpty() {
        return size == 0;
    }
}

在这里继承Comparable的原因是在二叉搜索树中每一个元素都应该是可进行比较的，因此继承了Comparable接口。

2. 向二叉搜索树中添加元素

本文中向二叉搜索树中添加元素时默认没有重复元素的情况，如果要包括有重复元素的情况只需要更改规则为左子树的每一个节点值小于等于根节点的值，右子树的每一个节点的值大于等于根节点的值即可，之后我会专门写一篇文章来实现这样的情况。在本文中向二叉搜索树中插入新的元素的方式主要使用递归的方式。
在BST.java文件中添加如下方法：

    // 向二分搜索树中添加新的元素e
    public void add (E e) {
        // 首先进行判断当前二分搜索树是否为空
        if (root == null) {
            // 创建一个新的根节点
            root = new Node(e);
            // 元素个数加 1
            size++;
        }

        // 如果二分搜索树不为空，则将当前元素添加到节点中
        add(root,e);

    }

    // 向以node为根的二分搜索树中插入元素e
    private void add (Node node, E e) {
        // 如果当前插入的元素和节点的元素值相同，说明当前元素已经插入到了节点中
        if (e.equals(node.e)) {
            return;
        // 如果当前元素小于根节点的值并且根节点的左子树为空
        } else if (e.compareTo(node.e) < 0 && node.left == null) {
            node.left = new Node(e);
            size++;
            return;
        // 如果当前元素大于根节点的值并且根节点的右子树为空
        } else if (e.compareTo(node.e) > 0 && node.right == null) {
            node.right = new Node(e);
            size++;
            return;
        }

        if (e.compareTo(node.e) < 0) {
            // 递归调用本身，在左子树中插入当前元素
            add(node.left, e);
        } else {
            // 递归调用在右子树中插入当前元素
            add(node.right, e);
        }
    }

在这里递归的终止条件分为三种情况：

  1. 第一种情况为当前插入元素的值与二叉搜索树中的某一个节点的值相同，此时认为当前元素已经存在与二叉搜索树中。
  2. 此时遍历到叶子节点并且当前元素的值小于此时叶子节点的值，将当前元素作为新的叶子节点（左子树）后返回
  3. 此时遍历到叶子节点并且当前元素的值大于此时叶子节点的值，将当前元素作为新的叶子节点（右子树）后返回

3. 改进插入元素的方法

在上面所写的代码中，if判断语句过于多，代码显得很冗长并且可读性差，因此可以改变一种思路向二叉搜索树中添加元素

  • 在刚才的代码中遍历到叶子节点时只是进行了对当前节点是否存在子节点的判断，实际上并未递归到底，因此可以将递归的终止条件修改为如果当前正在遍历的节点为空时，将要插入的元素作为参数构造出一个新的节点并将新的节点返回，将此时add方法的返回值由void更改为Node类型。此时在插入元素后，当前二叉搜索树的左子树或右子树就发生了改变，因此在递归调用add方法时要将返回的更改后的左右子树的值分别赋值给原本的左右子树。在对外展现的add方法中调用时也可以省略当前根节点是否为空的判断，因为本身要返回的就是一个新的节点。

因此新的插入元素的方法可以修改为：

	// 向二分搜索树中添加新的元素e
    public void add (E e) {
        // 如果二分搜索树不为空，则将当前元素添加到节点中
        root = add(root,e);
    }

	// 返回插入新节点后二分搜索树的根
	private Node add (Node node, E e) {
		
		if (node == null) {
			size++;
  	        return new Node(e);
   	    }

        if (e.compareTo(node.e) < 0) {
			// 递归调用本身，在左子树中插入当前元素
            node.left = add(node.left, e);
		} else if (e.compareTo(node.e) > 0){
			// 递归调用在右子树中插入当前元素
			node.right = add(node.right, e);
		}

	    // 将改变后的二分搜索树进行返回
		return node;
	}

在这里并没有对要进行插入的元素值与节点值相等的情况进行处理，因此在递归调用本身进行右子树的插入时要使用else if来进行判断。

四、二叉搜索树的查询

对于二分搜索树的查询操作来说，只需要对二叉搜索树的每一个节点中存储的元素进行查看即可。在查询时也创建一个私有的contains方法进行递归操作，传入参数为当前要进行遍历的二叉搜索树和要查询的元素。

  • 首先先对当前传来的二叉搜索树进行是否为空的判断，如果为空则直接返回false，接着将元素的值与节点中的值进行比较，如果比较结果等于0则说明当前二叉搜索树中存在当前元素，如果小于0则继续调用contains方法对左子树进行遍历查询，如果大于0则继续对右子树进行遍历查询。
    // 查看当前的二分搜索树中是否存在元素e
    public boolean contains (E e) {
        return contains(root, e);
    }

    // 查询以node为根的二分搜索树中是否存在元素e
    private boolean contains(Node node, E e) {

        if (node == null) {
            return false;
        }

        // 将元素e与节点中的值进行比较
        if (e.compareTo(node.e) < 0) {
            return contains(node.left, e);
        } else if (e.compareTo(node.e) > 0) {
            return contains(node.right, e);
        } else {
            return true;
        }
    }

五、测试

接下来就创建测试类Main.java对下图的二叉搜索树进行构造并进行遍历
在这里插入图片描述

1. 测试类代码

/**
 * @author Dream_飞翔
 * @date 2022/1/17
 * @time 22:08
 * @email 1072876976@qq.com
 */
public class Main {

    public static void main(String[] args) {
        // 创建一棵二分搜索树
        BST<Integer> bstTree = new BST<>();

        // 首先对二分搜索树是否为空进行判断
        System.out.println("当前二分搜索树是否为空：" + bstTree.isEmpty());
        // 查看当前二分搜索树中的元素个数
        System.out.println("二分搜索树中的元素个数为：" + bstTree.size());

        // 向二分搜索树中插入根节点
        bstTree.add(33);
        bstTree.add(28);
        bstTree.add(40);
        bstTree.add(19);
        bstTree.add(31);
        bstTree.add(35);
        bstTree.add(45);

        // 判断当前二分搜索树是否为空
        System.out.println("当前二分搜索树是否为空：" + bstTree.isEmpty());
        // 查看当前二分搜索树中的元素个数
        System.out.println("二分搜索树中的元素个数为：" + bstTree.size());

        System.out.println("------------------- 接下来查看二分搜索树中包含的元素 -------------------");

        System.out.println("二分搜索树中是否包含元素33：" + bstTree.contains(33));
        System.out.println("二分搜索树中是否包含元素28：" + bstTree.contains(28));
        System.out.println("二分搜索树中是否包含元素40：" + bstTree.contains(40));
        System.out.println("二分搜索树中是否包含元素19：" + bstTree.contains(19));
        System.out.println("二分搜索树中是否包含元素31：" + bstTree.contains(31));
        System.out.println("二分搜索树中是否包含元素35：" + bstTree.contains(35));
        System.out.println("二分搜索树中是否包含元素45：" + bstTree.contains(45));
        System.out.println("二分搜索树中是否包含元素100：" + bstTree.contains(100));

    }
}

2. 运行结果

在这里插入图片描述

六、源码（改进后）

/**
 * @author Dream_飞翔
 * @date 2022/1/17
 * @time 20:16
 * @email 1072876976@qq.com
 */
public class BST<E extends Comparable<E>> {
    // 声明二分搜索树的节点类
    private class Node {
        // 存放节点值的变量
        public E e;
        // 指向左子树和右子树的变量
        public Node left, right;

        public Node (E e) {
            this.e = e;
            // 将左子树和右子树初始化为空
            left = null;
            right = null;
        }
    }

    // 二分搜索树的根节点
    private Node root;
    // 当前二分搜索树存储的元素的个数
    private int size;

    public BST() {
        // 初始化时二分搜索树根节点为空
        root = null;
        // 存储了0个元素
        size = 0;
    }

    // 获取当前二分搜索树存储元素个数的方法
    public int size() {
        return size;
    }

    // 判断当前二分搜索树是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    // 向二分搜索树中添加新的元素e
    public void add (E e) {
        // 如果二分搜索树不为空，则将当前元素添加到节点中
        root = add(root,e);

    }

    // 向以node为根的二分搜索树中插入元素e
    // 返回插入新节点后二分搜索树的根
    private Node add (Node node, E e) {
        if (node == null) {
            size++;
            return new Node(e);
        }

        if (e.compareTo(node.e) < 0) {
            // 递归调用本身，在左子树中插入当前元素
            node.left = add(node.left, e);
        } else if (e.compareTo(node.e) > 0){
            // 递归调用在右子树中插入当前元素
            node.right = add(node.right, e);
        }

        // 将改变后的二分搜索树进行返回
        return node;
    }

    // 查看当前的二分搜索树中是否存在元素e
    public boolean contains (E e) {
        return contains(root, e);
    }

    // 查询以node为根的二分搜索树中是否存在元素e
    private boolean contains(Node node, E e) {

        if (node == null) {
            return false;
        }

        // 将元素e与节点中的值进行比较
        if (e.compareTo(node.e) < 0) {
            return contains(node.left, e);
        } else if (e.compareTo(node.e) > 0) {
            return contains(node.right, e);
        } else {
            return true;
        }
    }


}

七、总结

以上便是二叉搜索树的构造以及简单查询的递归实现，在本文中的二叉搜索树没有对当插入元素的值与树中某一节点的值相同的情况，在进行完二叉搜索树的先序、中序、后序以及层序遍历后会对插入元素的值与某一节点值相同的情况进行实现。

Dream_飞翔
关注
专栏目录
二叉查找树构建
VanillaSky
05-25 1186
给定n构建最大值为n的二叉查找树——树的形态种类 https://leetcode.com/problems/unique-binary-search-trees/ Given n, how many structurally unique BST’s (binary search trees) that store values 1…n? For example, Given n = 3,
如何用 java 实现【二叉搜索树】
超烦豆先森
12-29 1077
关于数据结构 二叉搜索树的 java 实现
构造二叉搜索树
Myueye的博客
03-08 318
节点 public class TreeNode { int val; TreeNode right; TreeNode left; public TreeNode() {}; public TreeNode(int val) { this.val = val; } public int getVal() { return val; } public void setVal(int val) { this.val = val; } public TreeNo
【数据结构】二叉搜索树
最新发布
Celia的博客
09-18 1939
左子树所有的值要小于根节点的值，右子树所有的值要大于根节点的值。这样一来，当查找一个值的时候，如果比当前节点的值小，就向左遍历；如果比当前节点的值大，就向右遍历。这样的搜索模式最好的时间复杂度为logN。二叉搜索树举例class BSTNode //每个节点的定义public:K val;
二叉搜索树（构造篇）
c630843901的博客
07-07 997
二叉搜索树（特性篇）讲了中序遍历对 BST 的重要意义,二叉搜索树（基操篇）写了 BST 的基本操作。本文循序渐进地讲两道题，如何计算所有有效 BST。力扣第 96 题「 不同的二叉搜索树」固定一个根节点后，其形状总数为左子树的组合数和右子树的组合数乘积 注意 base case，显然当闭区间肯定是个空区间，也就对应着空节点 null，虽然是空节点，但是也是一种情况，所以要返回 1 而不能返回 0。但是这样会出现很多重叠子问题，这时就需要备忘录来记录已经访问过的组合 当然这道题动态规划也可以解决 不同的二
数据结构-二叉搜索树
m0_61433144的博客
08-07 1759
二叉搜索树也称二叉排序树或者二叉查找树，它是在普通二叉树上加入一些特性所形成的： 1，若左子树非空，则左子树上所有结点的值均小于根结点的值。 2，若右子树非空，则右子树上所有结点的值均大于根结点的值。 3，其左右子树也分别是一棵二叉搜索树。......
Java二叉搜索树基础原理与实现方法详解
08-19
Java二叉搜索树基础原理与实现方法详解 本文详细介绍了Java二叉搜索树的基础原理与实现方法，涵盖了二叉树的定义、特点、二叉搜索树的定义、性质、思想、编程实现等方面的知识点。 一、树的定义 树是n（n>=0）个...
java实现 二叉搜索树功能
08-27
Java实现二叉搜索树功能的代码示例如下： ```java public class SearchBinaryTree<T extends Comparable<T>> { private Node<T> root; private int size; public SearchBinaryTree() { super(); } public ...
Java实现二叉排序树
09-02
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉排序树中，对于...
构造二叉搜索树（Java实现）
av12138的博客
02-25 1561
构造二叉搜索树 定义 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 特性 二叉搜索树中最左侧的节点是树中最小的节点，最右侧节点一定是树中最大的节点 采用中序遍历遍历二叉搜索树，可以得到一个有序的序列 代码实现 public class BSTree { //定义Node类 public s
数据结构（二）：二叉搜索树（Binary Search Tree）
mjiansun的专栏
04-11 1213
转自：数据结构（二）：二叉搜索树（Binary Search Tree） - 简书 (jianshu.com) 引子 定义 二叉搜索树是一种节点值之间具有一定数量级次序的二叉树，对于树中每个节点： 若其左子树存在，则其左子树中每个节点的值都不大于该节点值； 若其右子树存在，则其右子树中每个节点的值都不小于该节点值。 示例： 查询复杂度 观察二叉搜索树结构可知，查询每个节点需要的比较次数为节点深度加一。如深度为 0，节点值为 “6” 的根节点，只需要一次比较即可；深度为 1，节点
二叉查找树的构造
weixin_30387663的博客
10-22 131
使二叉树成为二叉查找数的性质是：对于树的每个节点x,它的左子树的所有值小于x项的值，它的右子树的所有值大于x项的值。 怎样构造一棵二叉查找树呢？ 首先设置树的数据结构 struct BinaryNode{ int element; BinaryNode *left; BinaryNode *rigth; BinaryNode(const int &theEle...
二叉查找树的构造算法
weixin_33877092的博客
06-05 163
今天来写一下二叉查找树的构造算法 二叉查找树：二叉查找树的的特点是所有节点的值要大于其左节点的值，小于其右节点的值。。。 因此我们在构造二叉查找树的查找算法的时候总是用要查找的数来和节点的值做一个比较，如果节点的值大于要查找的数，那么继续查找其左节点，反之则继续查找器右节点，一直到查找到你要的数。 本算法包括计算树的高度，树的叶子节点的数目，树的所有节点的数目，以及树的输出。 1.头文件 ...
二叉树系列---构造二叉查找树
bh_xiaoxinba的博客
11-02 370
构造二叉查找树package binary_tree;public class BuildBinarySearchTree { private Node root; public BuildBinarySearchTree(){ root=null; } public void insert(int data){ Node newNode=n
查找算法【二叉查找树】 - 二叉查找树的创建
谢谢你们的关注
10-27 2146
查找算法【二叉查找树】 - 二叉查找树的创建
Java数据结构之二叉搜索树
ZIYE_190的博客
04-02 334
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
PTA查找—构造二叉检索树
Scream的博客
11-15 3246
构造二叉检索树 本题目构造一棵二叉检索树。要求读入n个整数，以0结束。最后输出这棵树的先序序列。 输入格式: 输入n个整数，以0表示结束，数据间以空格隔开。 输出格式: 输出这棵树的先序序列，以一个空格隔开，结尾也有一个空格。 输入样例: 34 50 23 12 30 23 0 结尾无空行 输出样例: 34 23 12 23 30 50 结尾无空行 AC代码： #include<bits/stdc++.h> using namespace std; struct BSTree { int
Java实现二叉搜索树详解与代码示例
Java实现二叉搜索树功能是面向对象编程中的一种经典数据结构应用，它利用二叉树的特性进行高效的查找、插入和删除操作。本文将详细介绍如何在Java中创建和操作这种特殊的树结构。 首先，我们来理解二叉搜索树的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Dream_飞翔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值