Java深入了解数据结构之二叉搜索树增 插 删 创详解

 更新时间:2022年01月27日 15:13:24   作者:/少司命  
二叉搜索树是以一棵二叉树来组织的。每个节点是一个对象,包含的属性有left,right,p和key,其中,left指向该节点的左孩子,right指向该节点的右孩子,p指向该节点的父节点,key是它的值

①概念

二叉搜索树又称二叉排序树,它或者是一棵空树**,或者是具有以下性质的二叉树:

若它的左子树不为空,则左子树上所有节点的值都小于根节点的值

若它的右子树不为空,则右子树上所有节点的值都大于根节点的值

它的左右子树也分别为二叉搜索树

②操作-查找

二叉搜索树的查找类似于二分法查找

public Node search(int key) {
        Node cur = root;
        while (cur != null) {
            if(cur.val == key) {
                return cur;
            }else if(cur.val < key) {
                cur = cur.right;
            }else {
                cur = cur.left;
            }
        }
        return null;
    }

③操作-插入

  public boolean insert(int key) {
        Node node = new Node(key);
        if(root == null) {
            root = node;
            return true;
        }
 
        Node cur = root;
        Node parent = null;
 
        while(cur != null) {
            if(cur.val == key) {
                return false;
            }else if(cur.val < key) {
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
        //parent
        if(parent.val > key) {
            parent.left = node;
        }else {
            parent.right = node;
        }
 
        return true;
    }

④操作-删除

删除操作较为复杂,但理解了其原理还是比较容易

设待删除结点为 cur, 待删除结点的双亲结点为 parent

1. cur.left == null

1. cur 是 root,则 root = cur.right

2. cur 不是 root,cur 是 parent.left,则 parent.left = cur.right

3. cur 不是 root,cur 是 parent.right,则 parent.right = cur.right

2. cur.right == null

1. cur 是 root,则 root = cur.left

2. cur 不是 root,cur 是 parent.left,则 parent.left = cur.left

3. cur 不是 root,cur 是 parent.right,则 parent.right = cur.left

第二种情况和第一种情况相同,只是方向相反,这里不再画图

3. cur.left != null && cur.right != null

需要使用替换法进行删除,即在它的右子树中寻找中序下的第一个结点(关键码最小),用它的值填补到被删除节点中,再来处理该结点的删除问题

当我们在左右子树都不为空的情况下进行删除,删除该节点会破坏树的结构,因此用替罪羊的方法来解决,实际删除的过程还是上面的两种情况,这里还是用到了搜索二叉树的性质

public void remove(Node parent,Node cur) {
        if(cur.left == null) {
            if(cur == root) {
                root = cur.right;
            }else if(cur == parent.left) {
                parent.left = cur.right;
            }else {
                parent.right = cur.right;
            }
        }else if(cur.right == null) {
            if(cur == root) {
                root = cur.left;
            }else if(cur == parent.left) {
                parent.left = cur.left;
            }else {
                parent.right = cur.left;
            }
        }else {
            Node targetParent =  cur;
            Node target = cur.right;
            while (target.left != null) {
                targetParent = target;
                target = target.left;
            }
            cur.val = target.val;
            if(target == targetParent.left) {
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }
    }
 
  public void removeKey(int key) {
        if(root == null) {
            return;
        }
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if(cur.val == key) {
                remove(parent,cur);
                return;
            }else if(cur.val < key){
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
    }

⑤性能分析

插入和删除操作都必须先查找,查找效率代表了二叉搜索树中各个操作的性能。

对有n个结点的二叉搜索树,若每个元素查找的概率相等,则二叉搜索树平均查找长度是结点在二叉搜索树的深度 的函数,即结点越深,则比较次数越多。

但对于同一个关键码集合,如果各关键码插入的次序不同,可能得到不同结构的二叉搜索树:

最优情况下,二叉搜索树为完全二叉树,其平均比较次数为:

最差情况下,二叉搜索树退化为单支树,其平均比较次数为:

⑥完整代码

public class TextDemo {
 
    public static class Node {
        public int val;
        public Node left;
        public Node right;
 
        public Node (int val) {
            this.val = val;
        }
    }
 
 
    public Node root;
 
    /**
     * 查找
     * @param key
     */
    public Node search(int key) {
        Node cur = root;
        while (cur != null) {
            if(cur.val == key) {
                return cur;
            }else if(cur.val < key) {
                cur = cur.right;
            }else {
                cur = cur.left;
            }
        }
        return null;
    }
 
    /**
     *
     * @param key
     * @return
     */
    public boolean insert(int key) {
        Node node = new Node(key);
        if(root == null) {
            root = node;
            return true;
        }
 
        Node cur = root;
        Node parent = null;
 
        while(cur != null) {
            if(cur.val == key) {
                return false;
            }else if(cur.val < key) {
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
        //parent
        if(parent.val > key) {
            parent.left = node;
        }else {
            parent.right = node;
        }
 
        return true;
    }
 
    public void remove(Node parent,Node cur) {
        if(cur.left == null) {
            if(cur == root) {
                root = cur.right;
            }else if(cur == parent.left) {
                parent.left = cur.right;
            }else {
                parent.right = cur.right;
            }
        }else if(cur.right == null) {
            if(cur == root) {
                root = cur.left;
            }else if(cur == parent.left) {
                parent.left = cur.left;
            }else {
                parent.right = cur.left;
            }
        }else {
            Node targetParent =  cur;
            Node target = cur.right;
            while (target.left != null) {
                targetParent = target;
                target = target.left;
            }
            cur.val = target.val;
            if(target == targetParent.left) {
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }
    }
 
    public void removeKey(int key) {
        if(root == null) {
            return;
        }
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if(cur.val == key) {
                remove(parent,cur);
                return;
            }else if(cur.val < key){
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
    }
 
}

到此这篇关于Java深入了解数据结构之二叉搜索树增 插 删 创详解的文章就介绍到这了,更多相关Java 二叉搜索树内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • SpringBoot之如何指定配置文件启动

    SpringBoot之如何指定配置文件启动

    这篇文章主要介绍了SpringBoot之如何指定配置文件启动问题,具有很好的参考价值,希望对大家有所帮助。
    2023-04-04
  • SpringBoot调用第三方WebService接口的两种方法

    SpringBoot调用第三方WebService接口的两种方法

    本文主要介绍了SpringBoot调用第三方WebService接口的两种方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2023-06-06
  • Java基础之MapReduce框架总结与扩展知识点

    Java基础之MapReduce框架总结与扩展知识点

    本章,是MapReduce的最终章,我在写本章的时候,发现前面忘记介绍MpaTask与ReduceTask了,所以本章补上哈,另外还有两个扩展的知识点,讲完这些,我会对整个MapReduce进行总结一下,让大家再次了解MapReduce的工作流程,更加清晰地认识MapReduce ,需要的朋友可以参考下
    2021-05-05
  • springboot配置druid多数据源的示例代码

    springboot配置druid多数据源的示例代码

    这篇文章主要介绍了springboot配置druid多数据源的示例代码,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2022-09-09
  • JAVA提高第九篇 集合体系

    JAVA提高第九篇 集合体系

    这篇文章主要为大家详细介绍了JAVA提高第九篇集合体系的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2017-10-10
  • 基于redis key占用内存量分析

    基于redis key占用内存量分析

    这篇文章主要介绍了基于redis key占用内存量分析,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2020-11-11
  • MyBatis-Plus详解(环境搭建、关联操作)

    MyBatis-Plus详解(环境搭建、关联操作)

    MyBatis-Plus 是一个 MyBatis 的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生,今天通过本文给大家介绍MyBatis-Plus环境搭建及关联操作,需要的朋友参考下吧
    2022-09-09
  • Java编码辅助工具Mapstruct用法详解

    Java编码辅助工具Mapstruct用法详解

    这篇文章主要介绍了Java编码辅助工具Mapstruct用法详解,手动编码setter/getter各个对应属性,会显得臃肿繁琐。通过Mapstruct框架可简单方便地完成这一工作。,需要的朋友可以参考下
    2019-06-06
  • spring boot+mybatis-plus配置读写分离的操作

    spring boot+mybatis-plus配置读写分离的操作

    这篇文章主要介绍了spring boot+mybatis-plus配置读写分离的操作,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2024-01-01
  • SpringBoot使用Apache Tika实现多种文档的内容解析

    SpringBoot使用Apache Tika实现多种文档的内容解析

    在日常开发中,我们经常需要解析不同类型的文档,如PDF、Word、Excel、HTML、TXT等,Apache Tika是一个强大的内容解析工具,可以轻松地提取文档中的内容和元数据信息,本文将通过SpringBoot和Apache Tika的结合,介绍如何实现对多种文档格式的内容解析
    2024-12-12

最新评论