二叉搜索树Java实现

已于 2024-03-25 23:26:37 修改
阅读量534 收藏 9
点赞数 12
分类专栏： 数据结构与算法 文章标签： java 开发语言 深度优先
于 2024-03-25 19:00:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77821172/article/details/137020151
版权

二叉搜索树

一，概念

树节点增加key属性，用来比较大小，key不能重复

对于任意树节点，他的key比左子树大，比右子树小

1.前驱

比当前节点的key小的节点中，key最大的节点

左子树key最大的节点 或者 最后一个自左而来的节点

2.后继

比当前节点的key大的节点中，key最小的节点

右子树key最小的节点 或者 最后一个自右而来的节点

二，方法

注：节点类在最后实现代码中给出，由于导入原因，
缩进有所不同，可放入idea中一键格式化

1.put方法

不断根据key寻找插入位置，并通过prev记录上一个节点，

key存在则更新value，不存在则判断key与prev的key决定插入位置

public void put(KeyType key, ValueType value) {
        BSTNode<KeyType, ValueType> p = root;
        BSTNode<KeyType, ValueType> prev = null;
        while (p != null) {
            prev = p;
            int result = key.compareTo(p.key);
            if (result < 0) {
                p = p.left;
            } else if (result > 0) {
                p = p.right;
            } else {
                p.value = value;
                return;
            }
        }
        if (prev == null) {
            root = new BSTNode<KeyType, ValueType>(key, value);
            return;
        }
        if (key.compareTo(prev.key) < 0) {
            prev.left = new BSTNode<KeyType, ValueType>(key, value);
        } else {
            prev.right = new BSTNode<KeyType, ValueType>(key, value);
        }
    }
2.get方法

不断根据key寻找节点，找到返回对应的value，不存在返回null

public ValueType get(KeyType key) {
        BSTNode<KeyType, ValueType> p = root;
        while (p != null) {
            int result = key.compareTo(p.key);
            if (result < 0) {
                p = p.left;
            } else if (result > 0) {
                p = p.right;
            } else {
                return p.value;
            }
        }
        return null;
    }
3.寻找前驱

根据key寻找对应节点，并在每一次进入右子树之前记录当前节点为prev

左子树存在则前驱为左子树的最大值，否则为prev

 public ValueType findPrecursor(KeyType key) {
        BSTNode<KeyType, ValueType> precursor = findPrecursor(root, key);
        return precursor != null ? precursor.value : null;
    }
private BSTNode<KeyType, ValueType> findPrecursor(BSTNode<KeyType, ValueType> node, KeyType key) {
        BSTNode<KeyType, ValueType> p = node;
        BSTNode<KeyType, ValueType> pre = null;
        while (p != null) {
            if (key.compareTo(p.key) < 0) {
                p = p.left;
            } else if (key.compareTo(p.key) > 0) {
                pre = p;
                p = p.right;
            } else {
                break;
            }
        }
        if (p == null) {
            return null;
        }
        if (p.left == null) {
            return pre;
        }
        return max(p.left);
    }
4.寻找后继

根据key寻找对应节点，并在每一次进入左子树之前记录当前节点为prev

右子树存在则前驱为右子树的最小值，否则为prev

public ValueType findSubsequent(KeyType key) {
        BSTNode<KeyType, ValueType> subsequent = findSubsequent(root, key);
        return subsequent != null ? subsequent.value : null;
    }
private BSTNode<KeyType, ValueType> findSubsequent(BSTNode<KeyType, ValueType> node, KeyType key) {
        BSTNode<KeyType, ValueType> p = node;
        BSTNode<KeyType, ValueType> pre = null;
        while (p != null) {
            if (key.compareTo(p.key) < 0) {
                pre = p;
                p = p.left;
            } else if (key.compareTo(p.key) > 0) {
                p = p.right;
            } else {
                break;
            }
        }
        if (p == null) {
            return null;
        }
        if (p.right != null) {
            return min(p.right);
        }
        return pre;
    }
5.删除

根据key寻找当前节点并在每一次前进时记录当前节点为prev，继而分类讨论：

​ 1）左子树为空，将右子树继承到prev

​ 2）右子树为空，将左子树继承到prev

​ 3）左右都存在，寻找后继，

​ 后继与当前节点相邻：将后继节点继承到被删除节点的父节点上

​ 后继与当前节点不相邻：将后继节点的右子树继承到后继节点的父节点上，

​ 再将后继节点继承到被删除节点的父节点上，最后调整左右子节点为被删除节点的左右节点

//继承方法，将child通过curr与pre的节点关系继承到pre上，
//即删除curr，curr是左节点就将child集成到pre的左子树上
private void extend(BSTNode<KeyType, ValueType> pre, BSTNode<KeyType, ValueType> curr, BSTNode<KeyType, ValueType> child) {
        if (pre == null) {
            root = child;
        } else if (pre.left == curr) {
            pre.left = child;
        } else {
            pre.right = child;
        }
    }
 public ValueType remove(KeyType key) {
        BSTNode<KeyType, ValueType> p = root;       //待删除节点
        BSTNode<KeyType, ValueType> pre = null;     //待删除节点的父节点
        while (p != null) {
            if (key.compareTo(p.key) < 0) {
                pre = p;
                p = p.left;
            } else if (key.compareTo(p.key) > 0) {
                pre = p;
                p = p.right;
            } else {
                break;
            }
        }
        if (p == null) {    //未找到待删除节点
            return null;
        }
        if (p.left == null) {   //左子树为空
            extend(pre, p, p.right);
        } else if (p.right == null) {   //右子树为空
            extend(pre, p, p.left);
        } else {       //均不空，则寻找后继
            BSTNode<KeyType, ValueType> s = p.right;   //待删除后继
            BSTNode<KeyType, ValueType> sprev = null;   //待删除后继的父节点
            while (s.left != null) {     //寻找待删除后继
                sprev = s;
                s = s.left;
            }

            if (sprev.right != p) {     //后继与待删除节点不相邻
                extend(sprev, s, s.right);
                s.right = p.right;
            }
            extend(pre, p, s);
            s.left = p.left;
        }
        return p.value;
    }
6.遍历

这里就不过多赘述了，直接上代码

public void inOrders() {//中序遍历
        BSTNode<KeyType, ValueType> curr = root;
        Stack<BSTNode<KeyType, ValueType>> stack = new Stack<>();
        while (curr != null || !stack.isEmpty()) {
            if (curr != null) {
                stack.push(curr);
                curr = curr.left;
            } else {
                BSTNode<KeyType, ValueType> pop = stack.pop();
                System.out.println(pop.value);
                curr = pop.right;
            }
        }
    }

public void preOrders() {//前序遍历
        preOrders(root);
    }

private void preOrders(BSTNode<KeyType, ValueType> node) {
    if (node == null) {
        return;
    }
    System.out.print(node.value + "\t"); // 值
    preOrders(node.left); // 左
    preOrders(node.right); // 右
}

public void outOrders() {后序遍历
    BSTNode<KeyType, ValueType> curr = root;
    Stack<BSTNode<KeyType, ValueType>> stack = new Stack<>();
    BSTNode<KeyType, ValueType> pop = null;
    while (curr != null || !stack.isEmpty()) {
        if (curr != null) {
            stack.push(curr);
            curr = curr.left;
        } else {
            BSTNode<KeyType, ValueType> peek = stack.peek();
            if (peek.right == null || peek.right == pop) {
                pop = stack.pop();
                System.out.println(pop.value);
            } else {
                curr = peek.right;
            }
        }
    }
}
三，实现
package BSTTree;

import java.util.Stack;

public class BSTTree<KeyType extends Comparable<KeyType>, ValueType>{
    static class BSTNode<KeyType, ValueType> {
        KeyType key;
        ValueType value;
        BSTNode<KeyType, ValueType> left;
        BSTNode<KeyType, ValueType> right;

        public BSTNode(KeyType key) {
            this.key = key;
        }

        public BSTNode(KeyType key, ValueType value) {
            this.key = key;
            this.value = value;
        }

        public BSTNode(KeyType key, ValueType value, BSTNode<KeyType, ValueType> left, BSTNode<KeyType, ValueType> right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }

    private BSTNode<KeyType, ValueType> root;

    public ValueType min() {
        return min(root).value;
    }

    public ValueType max() {
        return max(root).value;
    }


    public ValueType get(KeyType key) {
        BSTNode<KeyType, ValueType> p = root;
        while (p != null) {
            int result = key.compareTo(p.key);
            if (result < 0) {
                p = p.left;
            } else if (result > 0) {
                p = p.right;
            } else {
                return p.value;
            }
        }
        return null;
    }

    public void put(KeyType key, ValueType value) {
        BSTNode<KeyType, ValueType> p = root;
        BSTNode<KeyType, ValueType> prev = null;
        while (p != null) {
            prev = p;
            int result = key.compareTo(p.key);
            if (result < 0) {
                p = p.left;
            } else if (result > 0) {
                p = p.right;
            } else {
                p.value = value;
                return;
            }
        }
        if (prev == null) {
            root = new BSTNode<KeyType, ValueType>(key, value);
            return;
        }
        if (key.compareTo(prev.key) < 0) {
            prev.left = new BSTNode<KeyType, ValueType>(key, value);
        } else {
            prev.right = new BSTNode<KeyType, ValueType>(key, value);
        }
    }

    public void inOrders() {
        BSTNode<KeyType, ValueType> curr = root;
        Stack<BSTNode<KeyType, ValueType>> stack = new Stack<>();
        while (curr != null || !stack.isEmpty()) {
            if (curr != null) {
                stack.push(curr);
                curr = curr.left;
            } else {
                BSTNode<KeyType, ValueType> pop = stack.pop();
                System.out.println(pop.value);
                curr = pop.right;
            }
        }
    }

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

    public void outOrders() {
        BSTNode<KeyType, ValueType> curr = root;
        Stack<BSTNode<KeyType, ValueType>> stack = new Stack<>();
        BSTNode<KeyType, ValueType> pop = null;
        while (curr != null || !stack.isEmpty()) {
            if (curr != null) {
                stack.push(curr);
                curr = curr.left;
            } else {
                BSTNode<KeyType, ValueType> peek = stack.peek();
                if (peek.right == null || peek.right == pop) {
                    pop = stack.pop();
                    System.out.println(pop.value);
                } else {
                    curr = peek.right;
                }
            }
        }
    }

    public ValueType findPrecursor(KeyType key) {
        BSTNode<KeyType, ValueType> precursor = findPrecursor(root, key);
        return precursor != null ? precursor.value : null;
    }

    public ValueType findSubsequent(KeyType key) {
        BSTNode<KeyType, ValueType> subsequent = findSubsequent(root, key);
        return subsequent != null ? subsequent.value : null;
    }

    public ValueType remove(KeyType key) {
        BSTNode<KeyType, ValueType> p = root;       //待删除节点
        BSTNode<KeyType, ValueType> pre = null;     //待删除节点的父节点
        while (p != null) {
            if (key.compareTo(p.key) < 0) {
                pre = p;
                p = p.left;
            } else if (key.compareTo(p.key) > 0) {
                pre = p;
                p = p.right;
            } else {
                break;
            }
        }
        if (p == null) {    //未找到待删除节点
            return null;
        }
        if (p.left == null) {   //左子树为空
            extend(pre, p, p.right);
        } else if (p.right == null) {   //右子树为空
            extend(pre, p, p.left);
        } else {       //均不空，则寻找后继
            BSTNode<KeyType, ValueType> s = p.right;   //待删除后继
            BSTNode<KeyType, ValueType> sprev = null;   //待删除后继的父节点
            while (s.left != null) {     //寻找待删除后继
                sprev = s;
                s = s.left;
            }

            if (sprev.right != p) {     //后继与待删除节点不相邻
                extend(sprev, s, s.right);
                s.right = p.right;
            }
            extend(pre, p, s);
            s.left = p.left;
        }
        return p.value;
    }

    private void preOrders(BSTNode<KeyType, ValueType> node) {
        if (node == null) {
            return;
        }
        System.out.print(node.value + "\t"); // 值
        preOrders(node.left); // 左
        preOrders(node.right); // 右
    }

    private void extend(BSTNode<KeyType, ValueType> pre, BSTNode<KeyType, ValueType> curr, BSTNode<KeyType, ValueType> child) {
        if (pre == null) {
            root = child;
        } else if (pre.left == curr) {
            pre.left = child;
        } else {
            pre.right = child;
        }
    }

    private BSTNode<KeyType, ValueType> findSubsequent(BSTNode<KeyType, ValueType> node, KeyType key) {
        BSTNode<KeyType, ValueType> p = node;
        BSTNode<KeyType, ValueType> pre = null;
        while (p != null) {
            if (key.compareTo(p.key) < 0) {
                pre = p;
                p = p.left;
            } else if (key.compareTo(p.key) > 0) {
                p = p.right;
            } else {
                break;
            }
        }
        if (p == null) {
            return null;
        }
        if (p.right != null) {
            return min(p.right);
        }
        return pre;
    }

    private BSTNode<KeyType, ValueType> findPrecursor(BSTNode<KeyType, ValueType> node, KeyType key) {
        BSTNode<KeyType, ValueType> p = node;
        BSTNode<KeyType, ValueType> pre = null;
        while (p != null) {
            if (key.compareTo(p.key) < 0) {
                p = p.left;
            } else if (key.compareTo(p.key) > 0) {
                pre = p;
                p = p.right;
            } else {
                break;
            }
        }
        if (p == null) {
            return null;
        }
        if (p.left == null) {
            return pre;
        }
        return max(p.left);
    }

    private BSTNode<KeyType, ValueType> max(BSTNode<KeyType, ValueType> node) {
        if (node == null) {
            return null;
        }
        BSTNode<KeyType, ValueType> p = node;
        while (p.right != null) {
            p = p.right;
        }
        return p;
    }

    private BSTNode<KeyType, ValueType> min(BSTNode<KeyType, ValueType> node) {
        if (node == null) {
            return null;
        }
        BSTNode<KeyType, ValueType> p = node;
        while (p.left != null) {
            p = p.left;
        }
        return p;
    }
数据结构-二叉搜索树(Java实现)
cj13106811623的博客
03-27 820
二叉搜索树也叫做二叉排序树,如果中序遍历,这棵二叉搜索树的结果就是有序的,它是具备以下性质的二叉树:
二叉搜索树(java实现)
WeiJiFeng_的博客
05-07 3390
目录 　　1 .插入元素思想与实现 　　2 .删除元素思想与实现 　　3 .完整代码 二叉搜索树定义 二叉搜索树，也称有序二叉树,排序二叉树，是指一棵空树或者具有下列性质的二叉树： 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 任意节点的左、右子树也分别为二叉查找树。 没有键值相等的...
验证二叉搜索树java实现
guiguchunqiu的博客
12-29 480
方法一：二叉树的中序遍历 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNod
【Java 数据结构】实现一个二叉搜索树
程序猿教你打篮球的博客
01-09 7071
本期主要讲解： 1、认识二叉搜索树 2、实现一个二叉搜索树 2.1 成员变量 2.2 insert 方法 2.3 search 方法 2.4 remove 方法(重点) 3、二叉搜索树总结
二叉搜索树的实现(java)
qq_56320180的博客
05-24 331
关于二叉搜索树的创建,插入,删除,遍历等等
二叉搜索树的Java实现
机械工程跑路哥
02-24 1849
一.树的概念 树的定义：树是由n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 树的特点： 1.每个结点有零个或多个子结点； 2.没有父结点的结点为根结点； 3.每一个非根结点只有一个父结点； 4.每个结点及其后代结点整体上可以看做是一棵树，称为当前结点的父结点的一个子树; 补：树的检索效率较高！ 结点的度： 一个结点含有的子树的个数称为该结点的度； —如E有两个子树，度为2； F有 KLM三个子树，度为3。根节点
【数据结构】Java实现二叉搜索树
yican2580的博客
07-31 1147
详细解析数据结构中的二叉搜索树，并用Java代码实现每一个操作
Java实现二叉搜索树
枫飘长安的博客
04-17 666
Java实现二叉搜索树
Java二叉搜索树
m0_64318128的博客
11-05 1489
二叉搜索树的概念、性质，二叉搜索树的实现
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
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 实现【二叉搜索树】
超烦豆先森
12-29 1077
关于数据结构 二叉搜索树的 java 实现
Java基础07
最新发布
m0_74977981的博客
11-11 496
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
JAVA-01-变量
LJH_laura_li的博客
11-08 348
在方法、构造函数或块内部定义的变量。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 851
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 639
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 327
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
Java实现二叉搜索树实例教程
在给定的文件信息中，“tree-java.rar_tree_二叉搜索树”表明这是一个使用Java语言实现的二叉搜索树相关的资源。该资源特别标记为“初学者看的代码”，意味着代码可能具有较为详细的注释，并且结构简单，容易理解，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值