自己动手写数据结构（12）——平衡二叉树（详解结点删除）

最新推荐文章于 2023-11-03 21:04:25 发布
最新推荐文章于 2023-11-03 21:04:25 发布
阅读量2.8k 收藏 34
点赞数 16
分类专栏： 数据结构 文章标签： avl 数据结构 二叉树 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31709249/article/details/103793590
版权

自己动手写数据结构总目录

具体内容：

该文章的源代码仓库为：https://github.com/MeteorCh/DataStructure/blob/master/Java/DataStructure/src/Searching/BinarySortingTree/AVLTree.java
在上一篇博客中实现了二叉排序树。我们发现，查找的效率取决于树的高度。比如对于{62,88,58,47,35,73,51,99,37,93}这样的数组，利用上一篇博客实现的插入，得到的二叉排序树为:
在这里插入图片描述
但当我们改变一下数组中元素的顺序，比如改成{35,37,47,51,58,62,73,88}，那得到的二叉排序树就为：
在这里插入图片描述
不难看出，这时的二叉排序树退化成了一个线性表。这时已经完全没有了二叉排序树的优势。次吃的解决方案是就是尽量让树的高度降低，那就要求树的左右孩子的高度尽可能相近，即树要尽可能平衡。

一、相关定义

  • 1.平衡二叉树： 是一种二叉排序树， 其中每个节点的左右子树的高度差至多等于1。这里有两个地方要注意：第一，平衡二叉树首先是一颗二叉排序树；第二，每个节点的左右子树高度差要么是0，要么是1。
  • 2.平衡因子： 为了描述节点的左右子树差，我们将二叉树上节点的左子树高度减去右子树高度得到的值称为该节点的平衡因子。根据二叉树的定义，每个节点的平衡因子为-1,0,1三个中的一个。
  • 3.最小不平衡子树： 距离插入节点最近的，且平衡因子的绝对值大于1的节点为根的子树， 称为最小不平衡子树。如下所示的二叉排序树，当插入35时，58的左子树高度为2，右子树高度为0，该树变不平衡，因此以节点58为根的子树为最小不平衡子树。
    在这里插入图片描述

二、平衡调整

从上面的图可以看出，要让不平衡的二叉排序树重新平衡，就需要对最小不平衡子树进行调整，使其平衡。有四种调整方式：LL型、RR型、LR型、RL型。在月雲之霄 大佬的博客中，对这四种调整讲的相当清楚了，我这里将月雲之霄 大佬的博客中的图整理成一张图（本文重点讲解删除的各种情况，插入的情况可以先去看看月雲之霄大佬的博客，讲的可以说非常好了），用来解释调整情况：
在这里插入图片描述

三、节点插入

通过上面的图示，我们知道LR和RL是LL和RR的组合情况。知道了这个，我们在插入节点的时候，从上往下，利用递归，插入后，判断插入过程路径上的节点的平衡因子，当平衡因子大于1或小于-1时，就去调整该接节点（根据递归的特性，在寻找插入点位置时，是从上到下的，那在判断平衡因子时，就是从下往上的，这样其实调整的肯定就是最小不平衡子树了）。在月雲之霄 大佬的博客中对插入讲的相当详细了，我这里就不赘述了，可以详细看一遍大佬的博客，肯定能理解。我这里用Java实现平衡二叉树，Java中没有C++中delete的操作，所以每个节点都要有一个成员变量存储其父节点信息。在左旋和右旋的时候，要调整对应的父节点信息，我们这里先来看看左旋和右旋的两种情况。

1.LL型旋转（即右旋）

这里仍然使用月雲之霄 大佬的博客中的图来说明：
在这里插入图片描述
实现代码为：

	protected TreeNode llRotate(TreeNode node){//LL型旋转
        TreeNode xNode=node.lChild;
        node.lChild=xNode.rChild;
        if (xNode.rChild!=null)
            xNode.rChild.parent=node;//父节点调整
        xNode.rChild=node;
        if (xNode.rChild!=null)
            xNode.rChild.parent=xNode;//父节点调整
        node.height=Math.max(getHeight(node.lChild),getHeight(node.rChild))+1;
        xNode.height=Math.max(getHeight(xNode.lChild),getHeight(xNode.lChild))+1;
        return xNode;
    }

可以看到上面对x和y的父节点都进行了一些调整操作。

2.RR型旋转（即左旋）

使用月雲之霄 大佬的博客中的图来说明：
在这里插入图片描述
实现代码为：

	protected TreeNode rrRotate(TreeNode node){//RR型旋转
        TreeNode xNode=node.rChild;
        node.rChild=xNode.lChild;
        if (xNode.lChild!=null)
            xNode.lChild.parent=node;//父节点调整
        xNode.lChild=node;
        if (xNode.lChild!=null)
            xNode.lChild.parent=xNode;//父节点调整
        node.height=Math.max(getHeight(node.lChild),getHeight(node.rChild))+1;
        xNode.height=Math.max(getHeight(xNode.lChild),getHeight(xNode.lChild))+1;
        return xNode;
    }

上面也对x和y的父节点都进行了一些调整操作。
LR型插入和RL型插入是LL和RR型的组合，都会调用上面两个函数，我这里就不写了。有这两个函数，我们再来看平衡二叉树中的节点删除问题。

四、节点删除

我感觉节点删除是平衡二叉树中最难的部分了，删除的以后要判断调整的类型。当然，平衡调整类型仍然是LL、RR、LR、RL这四种，但是，与插入不同的是，在结点删除的时候，要考虑调整结点是父节点的左孩子还是右孩子，所以每种类型又有两种情况，总共是8种情况。 关于为什么在插入的时候不需要考虑父节点，而在删除的时候要考虑父节点，我们在讨论部分讨论。

1.LL型删除

1.1 LLL型删除

这种情况是最小不平衡子树的根节点为父节点的左孩子的情况，我这里称之为LLL型调整，具体情况如下所示，要删除20节点，左图中红圈标记出来的部分会引起不平衡，我们要对其进行调整。调整部分中的y为其父节点的左孩子（LLL中第一个L的含义）。
在这里插入图片描述
假设y的父节点为parent，LLL型删除对应的代码为

	parent.lChild=llRotate(y);
	parent.lChild.parent=parent;

1.2 RLL型删除

这种情况是最小不平衡子树的根节点为其父节点的右孩子的情况，我这里称之为RLL型调整，具体情况如下所示，要删除80节点，左图中红圈标记出来的部分会引起不平衡，我们要对其进行调整。调整部分中的y为其父节点的右孩子（RLL中R的含义）。
在这里插入图片描述
假设y的父节点为parent，RLL型删除对应的代码为

	parent.rChild=llRotate(y);
	parent.rChild.parent=parent;

2.RR型删除

2.1 LRR型删除

这种情况是最小不平衡子树的根节点为父节点的左孩子的情况，我这里称之为LRR型调整，具体情况如下所示，要删除0节点，左图中红圈标记出来的部分会引起不平衡，我们要对其进行调整。调整部分中的y为其父节点的左孩子（LRR中L的含义）。
在这里插入图片描述
假设y的父节点为parent，LRR型删除对应的代码为

	parent.lChild=rrRotate(y);
	parent.lChild.parent=parent;

2.2 RRR型删除

这种情况是最小不平衡子树的根节点为其父节点的右孩子的情况，我这里称之为RRR型调整，具体情况如下所示，要删除80节点，左图中红圈标记出来的部分会引起不平衡，我们要对其进行调整。调整部分中的y为其父节点的右孩子（RRR中第一个R的含义）。
在这里插入图片描述
假设y的父节点为parent，RRR型删除对应的代码为

	parent.rChild=rrRotate(y);
	parent.rChild.parent=parent;

3.LR型删除

3.1 LLR型删除

这种情况是最小不平衡子树的根节点为父节点的左孩子的情况，我这里称之为LLR型调整，具体情况如下所示，要删除20节点，左图中红圈标记出来的部分会引起不平衡，我们要对其进行调整。调整时先对x节点进行RR型调整，再对y节点进行LL型调整。调整部分中的y为其父节点的左孩子（LLR中第一个L的含义）。
在这里插入图片描述
假设y的父节点为parent，LLR型删除对应的代码为：

	y.lChild =  rrRotate(y.lChild);
    y.lChild.parent=y;
    parent.lChild=llRotate(y);
    parent.lChild.parent=parent;

3.2 RLR型删除

这种情况是最小不平衡子树的根节点为父节点的右孩子的情况，我这里称之为RLR型调整，具体情况如下所示，要删除90节点，左图中红圈标记出来的部分会引起不平衡，我们要对其进行调整。调整时先对x节点进行RR型调整，再对y节点进行LL型调整。调整部分中的y为其父节点的右孩子（RLR中第一个R的含义）。
在这里插入图片描述
假设y的父节点为parent，RLR型删除对应的代码为：

	y.lChild =  rrRotate(y.lChild);
    y.lChild.parent=y;
    parent.rChild=llRotate(y);
    parent.rChild.parent=parent;

4. RL型删除

4.1 LRL型删除

这种情况是最小不平衡子树的根节点为父节点的左孩子的情况，我这里称之为LRL型调整，具体情况如下所示，要删除0节点，左图中红圈标记出来的部分会引起不平衡，我们要对其进行调整。调整时先对x节点进行LL型调整，再对y节点进行RR型调整。调整部分中的y为其父节点的左孩子（LRL中第一个L的含义）。
在这里插入图片描述
假设y的父节点为parent，LRL型删除对应的代码为：

	y.rChild =llRotate(y.rChild);
    y.rChild.parent=y;
    parent.lChild=rrRotate(y);
    parent.lChild.parent=parent;

4.2 RRL型删除

这种情况是最小不平衡子树的根节点为父节点的右孩子的情况，我这里称之为RRL型调整，具体情况如下所示，要删除50节点，左图中红圈标记出来的部分会引起不平衡，我们要对其进行调整。调整时先对x节点进行LL型调整，再对y节点进行RR型调整。调整部分中的y为其父节点的右孩子（RRL中第一个L的含义）。
在这里插入图片描述
假设y的父节点为parent，RRL型删除对应的代码为：

	y.rChild =llRotate(y.rChild);
    y.rChild.parent=y;
    parent.rChild=rrRotate(y);
    parent.rChild.parent=parent;

五、代码实现

用Java实现平衡二叉树，代码如下：

package Searching.BinarySortingTree;

/**
 * 平衡二叉树的实现
 * 使用示例：
 *         int[] data={20,10,0,30,40,50,60,90,80,70};
 *         AVLTree tree=new AVLTree(data);
 *         int findKey=30;
 *         System.out.println("键"+findKey+"在平衡二叉树中"+(tree.find(findKey)==null?"不存在":"存在"));
 * 删除的各类情况示例：
 *      1.右子树中LL型删除
 *         int[] data={20,10,0,30,40,50,60,90,80,70};
 *         AVLTree tree=new AVLTree(data);
 *         tree.deleteNode(70);
 *         tree.deleteNode(90);
 *         tree.deleteNode(80);
 *      2.左子树中LL型删除
 *         int[] data={20,10,0,30,40,50,60,90,80,70};
 *         AVLTree tree=new AVLTree(data);
 *         tree.insertData(-1);
 *         tree.deleteNode(20);
 *      3.右子树中RR型删除
 *         int[] data={20,10,0,30,40,50,60,90,80,70};
 *         AVLTree tree=new AVLTree(data);
 *         tree.deleteNode(70);
 *         tree.deleteNode(90);
 *         tree.deleteNode(80);
 *      4.左子树中RR型删除
 *         int[] data={20,10,0,30,40,50,60,90,80,70};
 *         AVLTree tree=new AVLTree(data);
 *         tree.insertData(25);
 *         tree.deleteNode(0);
 *      5.右子树中LR型删除
 *         int[] data={20,10,0,30,40,50,60,90,80,70};
 *         AVLTree tree=new AVLTree(data);
 *         tree.deleteNode(40);
 *         tree.deleteNode(50);
 *         tree.deleteNode(90);
 *      6.左子树中LR型删除
 *         int[] data={20,10,0,30,40,50,60,90,80,70};
 *         AVLTree tree=new AVLTree(data);
 *         tree.insertData(5);
 *         tree.deleteNode(20);
 *      7.右子树中RL型删除
 *         int[] data={20,10,0,30,40,50,60,80};
 *         AVLTree tree=new AVLTree(data);
 *         tree.deleteNode(40);
 *         tree.insertData(75);
 *         tree.deleteNode(50);
 *      8.左子树中RL型删除
 *         int[] data={20,10,0,30,40,50,60,90,80,70};
 *         AVLTree tree=new AVLTree(data);
 *         tree.insertData(15);
 *         tree.deleteNode(0);
 */
public class AVLTree {
    public static class TreeNode{
        protected int data;//数据
        protected TreeNode lChild,rChild,parent;//左孩子、右孩子、父节点
        protected int height;//树的高度

        public TreeNode(int data){
            this.data=data;
            lChild=rChild=parent=null;
            height=1;
        }

        public int getData() {
            return data;
        }
    }

    TreeNode root;

    public AVLTree(int[] data){
        for (int item:data)
            insertData(item);
    }

    public TreeNode find(int key){//利用非递归的方式实现查找
        TreeNode curNode=root;
        while (curNode!=null){
            if (key==curNode.data){
                return curNode;
            }else if (key<curNode.data){
                curNode=curNode.lChild;
            }else
                curNode=curNode.rChild;
        }
        return null;
    }

    public int getHeight(TreeNode node){
        return node==null?0:node.height;
    }

    public int getBalanceFactor(TreeNode node){
        if (node==null)
            return 0;
        return getHeight(node.lChild)-getHeight(node.rChild);
    }

    protected TreeNode llRotate(TreeNode node){//LL型旋转
        TreeNode xNode=node.lChild;
        node.lChild=xNode.rChild;
        if (xNode.rChild!=null)
            xNode.rChild.parent=node;//父节点调整
        xNode.rChild=node;
        if (xNode.rChild!=null)
            xNode.rChild.parent=xNode;//父节点调整
        node.height=Math.max(getHeight(node.lChild),getHeight(node.rChild))+1;
        xNode.height=Math.max(getHeight(xNode.lChild),getHeight(xNode.lChild))+1;
        return xNode;
    }

    protected TreeNode rrRotate(TreeNode node){//RR型旋转
        TreeNode xNode=node.rChild;
        node.rChild=xNode.lChild;
        if (xNode.lChild!=null)
            xNode.lChild.parent=node;//父节点调整
        xNode.lChild=node;
        if (xNode.lChild!=null)
            xNode.lChild.parent=xNode;//父节点调整
        node.height=Math.max(getHeight(node.lChild),getHeight(node.rChild))+1;
        xNode.height=Math.max(getHeight(xNode.lChild),getHeight(xNode.lChild))+1;
        return xNode;
    }

    public void insertData(int data){
        root=insertData(root,data);
        root.parent=null;
    }

    /**
     * 插入数据
     * @param data
     */
    protected TreeNode insertData(TreeNode node,int data) {
        if (node==null) {
            return new TreeNode(data);
        }
        else {
            if (data<node.data) {
                node.lChild=insertData(node.lChild,data);
                node.lChild.parent=node;
            }
            else if (data>node.data) {
                node.rChild=insertData(node.rChild,data);
                node.rChild.parent=node;
            }
            //更新树中节点的高度
            node.height=1+Math.max(getHeight(node.lChild),getHeight(node.rChild));
            int balance=getBalanceFactor(node);
            if (balance>1&&data<node.lChild.data)//LL型
                return llRotate(node);
            if (balance<-1&&data>node.rChild.data)//RR型
                return rrRotate(node);
            if (balance>1&&data>node.lChild.data){//LR型
                node.lChild=rrRotate(node.lChild);
                node.lChild.parent=node;
                return llRotate(node);
            }
            if (balance<-1&&data<node.rChild.data){//RL型
                node.rChild=llRotate(node.rChild);
                node.rChild.parent=node;
                return rrRotate(node);
            }
        }
        return node;
    }

    public void deleteNode(int data){//提供给外部操作的删除节点接口
        deleteNode(root,data);
    }

    public void deleteNode(TreeNode node,int key){
        if (node==null)
            System.out.println("数据表中不存在"+key);
        else {
            if (key==node.data)
                deleteNode(node);
            else if (key<node.data)
                deleteNode(node.lChild,key);
            else
                deleteNode(node.rChild,key);
            node.height=1+Math.max(getHeight(node.lChild),getHeight(node.rChild));
            int balance=getBalanceFactor(node);
            TreeNode tmp=node.parent;//保存变量，因为node.parent在llRotate时会变化
            boolean flag=checkChild(tmp,node);//flag为false代表在左子树上，true代表在右子树上
            if (balance>1&&getBalanceFactor(node.lChild)>=0) {//LL型
                if (flag){//右子树
                    System.out.println("RLL型删除");
                    tmp.rChild=llRotate(node);
                    tmp.rChild.parent=tmp;
                }else {//左子树
                    System.out.println("LLL型删除");
                    tmp.lChild=llRotate(node);
                    tmp.lChild.parent=tmp;
                }
            }
            if (balance > 1 && getBalanceFactor(node.lChild) < 0){ //LR型
                node.lChild =  rrRotate(node.lChild);
                node.lChild.parent=node;
                if (flag){
                    System.out.println("RLR型删除");
                    tmp.rChild=llRotate(node);
                    tmp.rChild.parent=tmp;
                }else {
                    System.out.println("LLR型删除");
                    tmp.lChild=llRotate(node);
                    tmp.lChild.parent=tmp;
                }
            }

            if (balance < -1 && getBalanceFactor(node.rChild) <= 0) {//RR型
                if (flag){//右子树
                    System.out.println("RRR型删除");
                    tmp.rChild=rrRotate(node);
                    tmp.rChild.parent=tmp;
                }else {//左子树
                    System.out.println("LRR型删除");
                    tmp.lChild=rrRotate(node);
                    tmp.lChild.parent=tmp;
                }
            }
            if (balance < -1 && getBalanceFactor(node.rChild) > 0){  //Rl型
                node.rChild = llRotate(node.rChild);
                node.rChild.parent=node;
                if (flag){
                    System.out.println("RRL型删除");
                    tmp.rChild=rrRotate(node);
                    tmp.rChild.parent=tmp;
                }else {
                    System.out.println("LRL型删除");
                    tmp.lChild=rrRotate(node);
                    tmp.lChild.parent=tmp;
                }
            }
        }
    }

    protected boolean checkChild(TreeNode parent,TreeNode child){
        //这里需要判断是接到左子树上还是右子树上
        if (parent!=null){
            if (parent.lChild==child)
                return false;
            else
                return true;
        }
        return false;
    }

    protected void deleteNode(TreeNode node){//节点的移除操作，分为节点有左子树或右子树为空，左右子树均不为空两种情况
        if (node.rChild==null||node.lChild==null){//右子树或右子树为空
            TreeNode replace=node.rChild==null?node.lChild:node.rChild;
            if (node.parent!=null){
                if (node==node.parent.lChild)
                    node.parent.lChild=replace;
                else if (node==node.parent.rChild)
                    node.parent.rChild=replace;
                if (replace!=null)
                    replace.parent=node.parent;
            }else { //如果node为根节点
                root=replace;
                replace.parent=null;
            }
            //清空node释放内存
            node.parent=node.lChild=node.rChild=null;
        }else {
            //找到node的左子树中最右边的叶节点
            TreeNode curNode=node.lChild;
            while (curNode.rChild!=null){
                curNode=curNode.rChild;
            }
            //将curNode的值直接赋值给删除节点
            node.data=curNode.data;
            deleteNode(curNode);
        }
    }
}

在最上面的注释里，我将各种删除情况的示例都备注了，想试的小伙伴可以试试。其实我们发现，上面的删除部分，deleteNode(TreeNode node) 这个函数的实现和上一篇博客中的代码是一模一样的，不理解的可以先看看上一篇博客。

六、讨论

1.为什么插入的时候不需要考虑左右子树问题？

这个思考一下，就可以知道，插入时，是确定了在左子树还是右子树上插入后，再进行插入调整操作。而删除时，是先删除，然后再判断二叉树是否平衡，然后调整。

MeteorChenBo
关注
  • 16
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
数据结构（十三）——二叉排序树
North_City_的博客
08-20 582
二叉排序树（BST）: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点， 要求左子节点的值比当前节点的值小， 右子节点的值比当前节点的值大。 特别说明： 如果有相同的值， 可以将该节点放在左子节点或右子节点 比如针对数据 (7, 3, 10, 12, 5, 1, 9) ， 对应的二叉排序树为： 二叉排序树的建立与遍历 package binarysorttreee; public class BinarySortTreeDemo { public stat
自己动手写数据结构（4）——二叉树
MeteorChenBo的博客
11-15 3738
自己动手写数据结构总目录：https://blog.csdn.net/qq_31709249/article/details/102962377 二叉树的主要应用在后面要介绍的搜索树、赫夫曼编码等领域。本文先介绍二叉树的基本定义及存储结构。 一、二叉树定义 1.二叉树定义： 二叉树是每个结点最多有两个子树的树结构，我这里不啰嗦。 2.满二叉树： 所有的中间节点都有两个孩子，所有的叶子节点都在同一...
广工数据结构实验——平衡二叉树
07-06
广工数据结构实验——平衡二叉树 里面含有：源代码、可执行程序、说明文档
平衡二叉树
Tomsanm的博客
09-19 4388
引出： 同样是12个月份数据，用不同的二叉树组成方式，他们的平均查找深度都不一样： 对于第一棵树：平均查找深度 = （1x1 + 2x2 + 3x3 + 3x4 + 2x5 +1x6）/12 = 3.5 第二棵树：3.0 第三棵树：6.5 由此我们看出：越是平衡的树，查找效率越高。 1. 平衡二叉树概念 在二叉搜索树的基础上：左右两个子树的平衡因子 &lt;= 1；这里的子树是包...
【数据结构】树（六）—— 二叉平衡树（C语言版）
haoweixl的博客
06-28 1444
【数据结构】树（六）—— 二叉平衡树（C语言版）前言 前言 在 《树（五）—— 二叉排序树》一文中，对二叉排序树进行性能分析时可知，当为二叉排序树时，其查找性能最佳，与二分查找类似。故需要对二叉排序树进行优化为二叉平衡树。 .........
数据结构之——平衡二叉树（内容详解）
热门推荐
m0_37914588的博客
12-29 3万+
一、基本概念 平衡二叉树也叫AVL树，它或者是一颗空树，或者具有以下性质的二叉排序树：它的左子树和左子树的高度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树。 二、结构 如基本概念所树，它具有一个左子树和一个左子树，且对于任意一个子树而言，左子树和右子树高度只差不超过1. 2.1 平衡二叉树判别 如下有3棵树，分别判断下哪个是平衡二叉树？ 图1： 图2：...
数据结构--十二月份对应的平衡二叉树(手写版)
最新发布
jinjin_csdn的博客
11-03 584
图片有些步骤跳过啦，若有不懂，看到必定解答！希望各位小伙伴都能够越来越好~
关于平衡二叉树的构建
TankyZhang的博客
04-16 2168
构建平衡二叉树 最近在玩数据结构搞到平衡二叉树部分觉得平衡二叉树的构建，分享一下自己的二叉树构建： 首先是树的节点的构建： public class BalanceNode { private int value; BalanceNode leftBalanceNode; BalanceNode rightBalanceNode; public Balan...
平衡二叉树（AVL树）
sgh666666的博客
12-15 640
平衡二叉树是在二叉搜索树的基础上增加了限制： ①：树的深度为logN。 ②：每个节点的左子树和右子树的高度最多差一的二叉搜索树。 基本操作：调整！！！ 引入平衡因子：左右子树的高度差。 当平衡因子绝对值大于等于2的时候，就需要调整。 单旋转比较简单，直接把被破坏节点下一个节点提上去，然后再根据二叉搜索树的特点进行换儿子即可。如下图： 实现： Position
数据结构基础：P4.2-树(二)---＞二叉平衡树
InnerPeaceHQ的博客
12-29 2205
本系列文章为浙江大学陈越、何钦铭数据结构学习笔记，前面的系列文章链接如下： 数据结构基础：P1-基本概念 数据结构基础：P2.1-线性结构—＞线性表 数据结构基础：P2.2-线性结构—＞堆栈 数据结构基础：P2.3-线性结构—＞队列 数据结构基础：P2.4-应用实例—＞多项式加法运算 数据结构基础：P2.5-应用实例—＞多项式乘法与加法运算-C实现 数据结构基础：P3.1-树(一)—＞树与树的表示 数据结构基础：P3.2-树(一)—＞二叉树及存储结构 数据结构基础：P3.3-树(一)—＞二叉树的遍历 数据结
1-12 二叉查找树与AVL树
lgd123abc的博客
01-17 986
1.1 定义 一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树； （4）没有键值相等的结点。 二叉查找树（Binary Search Tree），又叫：二叉搜索树，二叉排序树。 1.2 查找 步骤： 若根结点的值等于查找的值，成功； 若小于根结点的值，递归查左子树； 若大于根结点的值，递归查右子树； 若子树为空，查找不.
广工数据结构课程设计——平衡二叉树操作的演示
07-06
广工数据结构课程设计——平衡二叉树操作的演示 内含源代码、可执行程序以及相应的说明文档 实验的功能包括： [实现提示] (1) 初始，平衡二叉树为空树，操作界面给出查找、插入和删除三种操作供选择。每种操作均要...
C语言 数据结构平衡二叉树实例详解
01-20
数据结构平衡二叉树 参考代码如下： /* 名称：平衡二叉树 语言：数据结构C语言版 编译环境：VC++ 6.0 日期： 2014-3-26 */ #include #include #include #define LH +1 // 左高 #define EH 0 // 等高 #...
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
自己动手写数据结构——目录
MeteorChenBo的博客
11-07 2118
1.背景 从今天开始，准备趁着闲暇时间来自己实现一遍数据结构，为明年找工作提前做做准备。因为暂时还不确定自己是要找Java岗还是C++岗位，而且想趁着这个机会加深一下Java的学习，所以这里的用Java和C++两种语言实现。希望能和学习数据结构的小伙伴一起进步。本系列的博客是在《大话数据结构》的参考加上自己的理解实现的，鉴于自己水平有限，有些实现可能会存在一些问题，希望大家能在这里或者github...
自己动手写数据结构（9）——图的拓扑排序和关键路径
MeteorChenBo的博客
12-24 1745
一、拓扑排序 1.定义 AOV网： 在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，这样的有向图为顶点表示活动的网，成为AOV(Activity On Vertex Network)网。 拓扑序列 对一个有向无环图G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边<u,v>∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性...
自己动手写数据结构（6）——图及其五种存储结构
MeteorChenBo的博客
11-30 1347
一、图的相关定义 1.图的定义 图（Graph）是由顶点的有穷非空集合和顶点之间的边的集合构成的，通常表示为G<V,E>。其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。其中边分为有向和无向，故图也分为有向图和无向图。在树中，只能表示一对多的关系。而图中，任意两个顶点之间都可以连接，故图可以表示一对多的关系。 2.图的遍历 图有两种遍历方式，一种是深度优先遍历，一种则是广...
自己动手写数据结构（2）——栈和队列及其应用
MeteorChenBo的博客
11-08 782
自己动手写数据结构系列总目录：https://blog.csdn.net/qq_31709249/article/details/102962377 该文章的源代码仓库为： java：https://github.com/MeteorCh/DataStructure/tree/master/Java/LinkList/src/LinkList C++：https://github.com/Met...
Java算法与数据结构测试——二叉树
04-06
1. 什么是二叉树？ 二叉树是一种树形结构，其中每个节点最多有两个子节点。一个节点的左子节点比该节点小，右子节点比该节点大。二叉树通常用于搜索和排序。 2. 二叉树的遍历方法有哪些？ 二叉树的遍历方法包括前序遍历、中序遍历和后序遍历。前序遍历是从根节点开始遍历，先访问根节点，再访问左子树，最后访问右子树。中序遍历是从根节点开始遍历，先访问左子树，再访问根节点，最后访问右子树。后序遍历是从根节点开始遍历，先访问左子树，再访问右子树，最后访问根节点。 3. 二叉树的查找方法有哪些？ 二叉树的查找方法包括递归查找和非递归查找。递归查找是从根节点开始查找，如果当前节点的值等于要查找的值，则返回当前节点。如果要查找的值比当前节点小，则继续在左子树中查找；如果要查找的值比当前节点大，则继续在右子树中查找。非递归查找可以使用栈或队列实现，从根节点开始，每次将当前节点的左右子节点入栈/队列，直到找到要查找的值或者栈/队列为空。 4. 二叉树的插入与删除操作如何实现？ 二叉树的插入操作是将要插入的节点与当前节点的值进行比较，如果小于当前节点的值，则继续在左子树中插入；如果大于当前节点的值，则继续在右子树中插入。当找到一个空节点时，就将要插入的节点作为该空节点的子节点。删除操作需要分为三种情况：删除叶子节点、删除只有一个子节点的节点和删除有两个子节点的节点。删除叶子节点很简单，只需要将其父节点的对应子节点置为空即可。删除只有一个子节点的节点，需要将其子节点替换为该节点的位置。删除有两个子节点的节点，则可以找到该节点的后继节点（即右子树中最小的节点），将其替换为该节点，然后删除后继节点。 5. 什么是平衡二叉树？ 平衡二叉树是一种特殊的二叉树，它保证左右子树的高度差不超过1。这种平衡可以确保二叉树的查找、插入和删除操作的时间复杂度都是O(logn)。常见的平衡二叉树包括红黑树和AVL树。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

MeteorChenBo

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

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

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

打赏作者

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

抵扣说明：

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

余额充值