二叉树学习(二) BST插入,查找与删除

最新推荐文章于 2023-11-15 00:54:57 发布
最新推荐文章于 2023-11-15 00:54:57 发布
阅读量296 收藏
点赞数
分类专栏： 走心系列 算法与数据结构 文章标签： 二叉树 BST
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36922927/article/details/87467753
版权

二叉排序树

定义:大小关系:左孩子<根<右孩子 的二叉树
特点:中序遍历得到有序序列(升序)
节点的删除:无论是什么情况,都需要保证删除后的中序遍历结果仍然是有序
比如删除前;a,b,c,d,e,f
如果删除c:需要保证删除c后,得到的中序遍历是a,b,d,e,f

删除大体分三种情况:

  1. 待删除节点无孩子(待删除节点是叶子节点),只需要将父节点将对应指针域置为null
  2. 待删除节点有一个孩子(左孩子或者是右孩子):以左孩子为例,将父节点指向待删除的节点的指针指向待删除节点的孩子节点(这里是左孩子)
  3. 待删除节点有两个孩子:这就比较麻烦,需要找到被删除节点的后继节点,将key值拷贝到被删除节点的数据域,然后删除被删除 节点的后继节点
  4. 还有一点比较特殊的:如果待删除节点是根节点,那么删除后的的二叉树根是变化了

java 代码实现:
BTreeNode.java 的定义,参见上一篇博文,传送

1.构建排序二叉树:


/**
 * @author wangwei
 * @date 2019/2/15 16:18
 * @classDescription 二叉排序树
 * 定义:满足左<根<右关系的二叉树
 */
public class BST {
    /**
     * 1.插入节点
     */
    public static BTreeNode insertNode(BTreeNode tree, Integer newKey) {
       if(null==tree){
           return new BTreeNode(newKey);
       }
        //如果节点已经存在,则返回,不再插入
        if (null != searchNode(tree, newKey)) {
            System.out.println("---- found ---" + newKey);
            return tree;
        }
        BTreeNode currNode = tree;
        BTreeNode preNode = null;
        BTreeNode newNode = new BTreeNode(newKey);
        while (currNode != null) {
            preNode = currNode;
            //newKey 较小,往左子树查找
            if (newKey < (int) currNode.getData()) {
                currNode = currNode.getLChild();
                //newKey较大,往右子树查找
            } else {
                currNode = currNode.getRChild();
            }
        }
        //处理节点插入:新节点应该是插入到preNode 的孩子位置,退出循环时是 currNode=null
        if (newKey < (int) preNode.getData()) {
            preNode.setLChild(newNode);
            return tree;
        }
        preNode.setRChild(newNode);
        return tree;

    }

2 节点搜索

/**
     * 2. 搜索节点
     *
     * @param tree
     * @param targetKey
     * @return 搜索节点
     */
    public static BTreeNode searchNode(BTreeNode tree, Integer targetKey) {

        if (tree == null || tree.getData() == null) {
            return null;
        }
        if (targetKey > (int) tree.getData()) {
            return searchNode(tree.getRChild(), targetKey);
        }
        if (targetKey < (int) tree.getData()) {
            return searchNode(tree.getLChild(), targetKey);
        }
        if(targetKey==(int)tree.getData()){
            return tree;
        }
        return null;
    }

3 节点删除

节点的删除比较麻烦:

  1. 如果被删除节点是叶子节点,或者是只有一个孩子,那么是很简单的
  2. 如果被删除节点是有两个孩子,需要寻找后继,拷贝后继的值到被删除节点,然后实际是删除被删除节点的后继节点
  3. 如果被删除节点是根节点,那么又得分上面的三种情况

具体java代码实现:

 
    /**
     * @param tree
     * @param targetKey
     * @return 删除节点, 分为2种情况
     * 1, 待删除节点是根节点(继续细分是否有左右孩子的请情况)
     * 2, 不是跟根节点
     * 2.1, 待删除节点只有一个孩子,将父节点的对应孩子指针指向被删除节点的孩子
     * 2.2,待删除节点有俩孩子(需要找到被删除节点的后继,将后继的值复制到被删除位置,然后删除后继节点
     */
    public static BTreeNode deleteNode(BTreeNode tree, Integer targetKey) {

        if (null == tree) {
            throw new RuntimeException("不能在空树中删除节点");
        }
        BTreeNode targetNode = searchNode(tree, targetKey);
        if (null == targetNode) {
            throw new RuntimeException("删除节点不存在");
        }
      
        //寻找被删除节点以及其对应的父节点
         BTreeNode parent = findParentNode(tree,targetKey);
        //如果父节点为null,这个是需要考虑的,表示待删除节点是根节点,那么删除之后后继将作为新的根节点


        //目前为止找到了待删除节点的父节点
        //需要注意的是 是左孩子还是右孩子
        //1.被删除节点是根节点
        if (null == parent) {
            //System.out.println("删除节点是根节点,暂时未处理,需要后继节点值覆盖根节点值,然后删除后继节点");
            //1.1 根节点没有右孩子,删除根之后,返回左子树
            if (null == targetNode.getRChild()) {
                return targetNode.getLChild();
            }
            // 1.2 根节点没有左孩子,返回右子树
            if (null == targetNode.getLChild()) {
                return targetNode.getRChild();
            }
               //1.3 左右孩子都有,需要查找根节点的后继,将后继的值复制到根节点,同时删除后继节点
            BTreeNode rChild = targetNode.getRChild();
            BTreeNode mostLChild =findSuccessorNode(targetNode);
            BTreeNode mostLChildParent = findParentNode(mostLChild,(int)mostLChild.getData());
            targetNode.setData(mostLChild.getData());
            if (mostLChildParent != null) {
                mostLChildParent.setLChild(null);
            } else {
                //处理根节点的右孩子没有左子树
                targetNode.setRChild(rChild.getRChild());
            }
            return targetNode;
        }


        BTreeNode lChild = parent.getLChild();
        BTreeNode rChild = parent.getRChild();
        //2,处理被删除节点只有一个孩子的情况
        //左孩子节点是被删除节点
        if (lChild != null && lChild.getData().equals(targetKey)) {
            BTreeNode lLChild = lChild.getLChild();
            BTreeNode lRChild = lChild.getRChild();
            //被删除节点无孩子
            //2.1 被删除节点无孩子
            boolean noChild = (null == lRChild && null == lLChild);
            if (noChild) {
                parent.setLChild(null);
                return tree;
            }
            //2.2被删除节点只有一个孩子
            boolean onlyOneChild = null == lRChild ^ null == lLChild;
            if (onlyOneChild) {
                parent.setLChild(null == lRChild ? lLChild : lRChild);
                return tree;
            }
            // 2.3 被删除节点有两个孩子
            //被删除节点有两个孩子  根据排序二叉树的特性  中序遍历是升序排列,那么删除节点后仍然需要满足升序排列
            //也就是需要找被删除节点的后继作为被删除节点的前驱的后继   ,使用这样找到的节点去替换被删除节点的值,然后删除找到的那个节点
            // 被删除节点的后继应该是 该节点的右孩子的最左孩子
            BTreeNode mostLChild = findSuccessorNode(lChild);// 查找被删除节点的后继
            BTreeNode mostLChildParent = findParentNode(tree,(int)mostLChild.getData());//最左孩子的父节点(被删除节点的后继的父节点)

            //将 后继(最左孩子mostLChild)的值拷贝到 被删除节点位置
            //同时删除最左孩子
            lChild.setData(mostLChild.getData());
            if (mostLChildParent != null) {
                mostLChildParent.setLChild(null);
            } else {
                //这是处理 被删除节点右孩子没有最左子节点的情况,后继就是被删除节点的右孩子
                lChild.setRChild(lRChild.getRChild());
            }
            return tree;
        }
        //3,待删除节点是右孩子,需要找到被删除节点的右孩子的最左孩子
        if (rChild != null && rChild.getData().equals(targetKey)) {

            BTreeNode rLChild = rChild.getLChild();
            BTreeNode rRChild = rChild.getRChild();
            //3.1 被删除节点无孩子
            boolean noChild = (null == rLChild && null == rRChild);
            if (noChild) {
                parent.setRChild(null);
                return tree;
            }
            //3.2 被删除节点 只有一个孩子
            boolean onlyOneChild = null == rLChild ^ null == rRChild;
            if (onlyOneChild) {
                parent.setRChild(null == rLChild ? rRChild : rLChild);
                return tree;
            }
            // 处理被删除节点带两个孩子节点的情况
            // 3.3  被删除节点有两个孩子
            //被删除节点有两个孩子  根据排序二叉树的特性  中序遍历是升序排列,那么删除节点后仍然需要满足升序排列
            //也就是需要找被删除节点的后继作为被删除节点的前驱的后继   ,使用这样找到的节点去替换被删除节点的值,然后删除找到的那个节点
            // 被删除节点的后继应该是 该节点的右孩子的最左孩子
            BTreeNode mostLChild = findSuccessorNode(rChild);
            BTreeNode mostLChildParent = findParentNode(tree,(int)mostLChild.getData());//后继节点的父节点
            //将 后继(最左孩子mostLChild)的值拷贝到 被删除节点位置
            //同时删除最左孩子
            rChild.setData(mostLChild.getData());
            if (mostLChildParent != null) {
                mostLChildParent.setLChild(null);
            } else {
                //这是处理 被删除节点的右孩子没有左孩子的情况,那么被删除节点的后继就是被删除节点的右孩子
                //由于将后继的值拷贝到被删除节点位置了,那么就需要将被删节点的右孩子指向
                // 原本被删节点的右孩子的右孩子
                rChild.setRChild(rRChild.getRChild());
            }
            return tree;
        }
        return tree;
    }

    /**
     * 查找key节点的父节点
     *
     * @param root
     * @param key
     * @return
     */
    public static BTreeNode findParentNode(BTreeNode root, Integer key) {
        if (null == root) {
            return null;
        }
        if(null==searchNode(root,key)){
            throw new RuntimeException("节点不存在");
        }
        BTreeNode parent = null;
        BTreeNode currNode = root;
        while (currNode != null && !currNode.getData().equals(key)) {
            parent = currNode;
            currNode = key > (int) currNode.getData() ? currNode.getRChild() : currNode.getLChild();
        }
       return parent;
    }

    /**
     *  查找后继节点(中序遍历中的后继节点:即右孩子的最左孩子)
     * @param startPoint
     * @return
     */
    public static BTreeNode findSuccessorNode(BTreeNode startPoint){
        if(null==startPoint){
            return null;
        }
        BTreeNode successorNode=startPoint.getRChild();
        while (successorNode!=null && successorNode.getLChild()!=null ){
            successorNode=successorNode.getLChild();
        }
        return successorNode;
    }

4测试代码:

在这里插入图片描述

测试用例:

以下均是通删除节点之后,检查中序遍历结果是否为升序,来判断是否操作成功.

  1. 删除10(根节点)
    在这里插入图片描述
  2. 删除叶子节点:1
    在这里插入图片描述
  3. 删除只有一个孩子的节点:7
    在这里插入图片描述
  4. 删除有两个孩子的节点:2
    在这里插入图片描述

/**
 * @author  wangwei
 * @date     2019/2/15 17:08
 * @classDescription  排序二叉树测试
 *
 */

public class BSTTest {
   @Test
    public void testInsert(){
     int []nums=  {10,2,5,7,8,9,10,3,1,14};

     BTreeNode tree=null;
     for(int num:nums){
         System.out.println(num);
       tree= BST.insertNode(tree,num);
     }
     Queue<Integer> queue=new ArrayDeque<>();
     BTreeNode.inorderVisit(tree,queue);
      System.out.println(queue.toString());
       Queue<Integer> queue2=new ArrayDeque<>();
       System.out.println("删除10 之后-----------");
       tree=BST.deleteNode(tree,10);
       BTreeNode.inorderVisit(tree,queue2);
       System.out.println(queue2.toString());
    }

}

总结:

  1. 节点的删除比较有难度
  2. 仔细观察发现,这样完全依赖输入的序列直接构建排序二叉树,高度是不太可控的,比如输入序列有序性非常高,完全升序,那么树的高度就会很高,查找效率由o(lgn )降为 o(n)
    如何改善这一问题呢?平衡二叉树就是为了保证查找效率而提出的,通过调整旋转使得高度比较统一,下一篇博客将介绍平衡二叉树的代码实现.
大卫不加班
关注
专栏目录
JavaScript数据结构与算法之二叉树插入节点、生成二叉树示例
10-17
由于其特性，二叉搜索树在搜索、插入和删除操作上具有较高的效率，特别是对于近似有序的数据集。 总结一下，本篇文章主要介绍了如何使用JavaScript实现二叉搜索树的插入节点功能。通过理解二叉搜索树的概念和插入...
进一步理解平衡二叉树(插入)
weixin_57023347的博客
09-04 4317
前言 前面我们了解了二叉搜索树，也进行了对二叉搜索树的简单实现。但是二叉搜索树存在一个缺陷。 当要在搜索树里插入或者删除数据时，都需要进行查找。查找体现了搜索树的效率。当插入二叉树搜索树的集合是一个有序序列时，二叉搜索树会形成一个单支树。变成一个链状结构，这样查找的效率大大降低，最坏情况下，查找的效率为O(N)。并没有很好的体现出搜索树的性质。 而平衡二叉树就很好的体现出了搜索树的性质，查找的效率是树的高度次，最坏的情况下查找的效率是O(logN)。 ...
【算法题解】BST二叉搜索树的特性 - 刷题必备
qq_43751336的博客
11-17 203
BST特性1. 中序遍历的序列是递增排序的序列2. Successor 代表的是中序遍历序列的下一个节点。即比当前节点大的最小节点，简称后继节点。 先取当前节点的右节点，然后一直取该节点的左节点，直到左节点为空，则最后指向的节点为后继节点。3. Predecessor 代表的是中序遍历序列的前一个节点。即比当前节点小的最大节点，简称前驱节点。先取当前节点的左节点，然后取该节点的右节点，直到右节点为空，则最后指向的节点为前驱节点。 1. 中序遍历的序列是递增排序的序列 public LinkedList&lt
二叉树的插入与删除
wu___hao的博客
11-29 5253
排序规则：定义一个vector数组，将数组中的第一个值作为根节点，此后将后面的值与根节点的值比较，如果小于根节点的值，则放在根节点的左边，如果大于根节点的值，放在根的右边。以此类推，根节点的左子树(右子树)又是一棵二叉树。此外，在二叉树排序中不允许出现两个相同的值。当二叉树完成之后，可以用中序遍历的方式将它从小到达排序。 定义结构体BstNode和BSTree分别定义了它们的属性和根节点，这里会增加一个双亲指针，它可以让我们的子节点指向它的父节点，但是这样也会降低它的存储密度。即原来12个字节中可以存储
36 C语言二叉树插入、删除、查找、遍历详解
Chasing_Chasing的博客
06-30 3547
36.1 前言 数据结构对于一个嵌软工程师来说，用到的最多的有数组、链表（单向、双向、循环链表等），对于其他的数据结构除非在开发存储模块，否则很难会用到其它的数据结构。但为了防范于未然，将来可能需要用到，因此我特地花了一些时间想要把那些软件工程师天天挂嘴边的二叉树啥的学习了一遍，并手写代码。写此篇博客，一是为了总结学习二叉树中获得的零散知识；二是希望把自己学习过程及理解分享，便于大家参考更快的学...
数据结构——平衡二叉树(AVL树)之插入
weixin_57023347的博客
06-17 7599
文章目录前言一.定义二.基本操作1.查找，删除2.插入(如何调整)如何调整代码实现插入 前言 首先我们来思考一下一个普通二叉树保存数据，如果想查找一个数据，由于普通二叉树保存数据是随机的，要找到数据的时间复杂度为O(n)。后面为了方便 ，我们又学习二叉搜索树，它的定义是将比根节点小的数放左边，比根节点大的数放右边，并且每一课子树都是二叉搜索树这样使得数据在树上存储有一定 的规律，在一定情况下查找起来很方便。但是，二叉搜索数当给出数据的顺序不同时，二叉搜索树也会不同。比如如果给出的序列为{1，2，3，4，5}
BST.rar_ 二叉树 _bst
09-21
"BST.cpp"可能包含了实现上述操作的C++代码，通过类或者结构体来表示节点，以及相应的插入、查找、删除和遍历的函数。"www.pudn.com.txt"可能是提供实验指导或相关资源的链接。 在进行二叉搜索树的操作时，需要注意...
BST树节点的插入，删除和查找
12-02
BST树因其特定的性质，为数据的快速插入、删除和查找提供了便利。在实际应用中，二叉搜索树常用于实现动态集合或映射，例如数据库索引。虽然BST在最坏情况下（树退化成链表）性能会降低，但在平均情况下仍能保持较好...
BST.zip_bst问题_二叉树
09-20
二叉查找树（BST，Binary Search Tree），也称为二叉排序树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键值、一个指向左子树的指针和一个指向右子树的指针。在BST中，每个节点的键值都大于其左子树中的...
【数据结构】——搜索二叉树的插入，查找和删除（递归&非递归）
02-26
【数据结构】——搜索二叉树的插入，查找和删除（递归&非递归） 在计算机科学中，数据结构是存储和组织数据的方式，它直接影响到数据的处理效率。搜索二叉树（BST，Binary Search Tree）是一种特殊类型的数据结构，...
【数据结构】树与二叉树（十六）：二叉树的基础操作：插入结点（算法Insert）
最新发布
天地玄黄 魑魅魍魉 风花雪月 商角徵羽 暂时停更 十月重见
11-15 1332
本文介绍了二叉树的基础操作——插入结点（左插入、右插入），包括ADL语言、时间复杂度分析及C语言实现
DAY24：二叉树（十四）二叉搜索树中的插入操作+删除二叉搜索树中的节点（二叉树结构修改难点）
CFY1226的博客
06-15 981
也就是说，当调用。
二叉树——二叉搜索树中的插入操作
ljh5930的博客
03-01 941
给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。返回插入后二叉搜索树的根节点。输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。你可以返回 任意有效的结果。
【二叉树】二叉搜索树中的插入操作
豪冷的博客
06-08 733
题目 给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value 将值插入二叉搜索树 返回插入后二叉搜索树的根节点 输入数据保证 新值和原始二叉搜索树中的任意节点值都不同 注意，可能存在多种有效的插入方式 只要树在插入后仍保持为二叉搜索树即可 你可以返回任意有效的结果...
二叉搜索树（查找、插入、删除的讲解实现+图文并茂）
bang___bang_的博客
05-25 8334
本文讲解并模拟实现二叉搜索树，详解它的查找、插入、删除及实现，并对二叉搜索树的应用场景进行描述，最后进行了性能分析！
二叉树遍历、插入、删除等常见操作
热门推荐
Sunshine的专栏
12-03 1万+
1.二叉查找树的创建 2.二叉查找树清空 3.二叉查找树查询 4.查找最大值、最小值 5.二叉查找树插入操作 6.二叉查找树的删除操作 7.分别使用非递归和递归方式（部分用多种方式）实现树的先序遍历、中序遍历和后序遍历
C++数据结构第63课、二叉树中的结点插入操作
xiebs的博客
08-27 2029
我们在进行插入操作的时候不是二叉树的任意结点都能插入，必须得指明插入新结点的位置，是左子树还是右子树，如果不指明便是默认从左向右的进行插入。 因此我们得定义一个枚举，用来表示二叉树结点的位置。 插入操作分为两种： — 插入新结点 bool insert(TreeNode<T>* node) bool insert(TreeNode<T>* node, BTNodePos pos) — 插入数据元素 bool insert(const T& value, TreeNode..
[Leetcode]-701. 二叉搜索树中的插入操作(二叉树）
m0_38100278的博客
09-30 315
题目： 给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据保证，新值和原始二叉搜索树中的任意节点值都不同。 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回任意有效的结果。 思路： 二叉搜索树（BST）定义，判断插入值应在根节点的左树或右树， 不断递归，直到找到符合条件的空节点 解答: /** * Definition for a binary tree node. * public clas
二叉树（十六）：二叉搜索树中的插入操作
qq_42138662的博客
06-21 1698
一、二叉搜索树中的插入操作 二叉搜索树中的插入操作 给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。 插入方法：当不考虑改变树的结构是，只要遍历二叉搜索树，找到空节点，插入元素就可以了 1、递归方法一（使用返回值完成父子节点赋值操作）（推荐） 注意这里通过递归函数返回值完成父子节点
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值