AVL树详解（实现AVL树，涉及单旋和双旋，有图解，超详细）

最新推荐文章于 2023-11-07 13:23:53 发布
最新推荐文章于 2023-11-07 13:23:53 发布
阅读量3.5k 收藏 2
点赞数
文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HBINen/article/details/127984392
版权

目录

AVL树是什么？

在讲AVL树是什么之前，我们要先知道什么是二叉搜索树
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树
    二叉搜索树的搜索效率很高，能达到（logn）的时间复杂度，但是如果说二叉搜索树的元素是一个有序序列，那么就会变成一个单分支树搜索的时间复杂度最坏就变成了O(N)，如下图，就是二叉搜索变成了单分支树
    在这里插入图片描述
    此时就引入AVL树进行优化，看AVL树的需要满足的条件：
  • 它的左右子树都是AVL树
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
    在这里插入图片描述

AVL树其实就是在二叉搜索树插入新元素时，维护平衡因子的绝对值不超过1而已，接下来就来实现一下AVL树的插入操作

AVL树的插入操作

很明显，AVL树的结点我们不仅需要左右孩子的引用，还得定义一个字段作为平衡因子（右子树高度-左子树高度），但是我们还要定义一个指向父亲节点的引用，方便我们进行插入操作之后，向上调整平衡因子，看下面代码对AVL树节点的定义：

static class TreeNode {
        public int val;//值
        public int bf;//平衡因子(右子树高度-左子树高度）
        public TreeNode left;//左孩子引用
        public TreeNode right;//右孩子引用
        public TreeNode parent;//父亲节点的引用

        public TreeNode(int val) {
            this.val = val;
        }
    }

插入一共有三个步骤：

  • 寻找插入位置
  • 将节点插入
  • 调整平衡因子
    前面两步没什么好讲的，基本更二叉搜索树没有区别

寻找插入位置

话不多说，直接看代码

TreeNode node = new TreeNode(val);
        if(root == null) {
            root = node;
            return true;
        }
        TreeNode parent = null;
        TreeNode cur = root;
        while(cur!=null) {
            if(cur.val<val) {
                parent = cur;
                cur= cur.right;
            } else if(cur.val==val) {
                return false;
            } else {
                parent = cur;
                cur = cur.left;
            }
        }

将节点插入

也是 直接 看代码

//cur==null
        if(parent.val<val) {
            parent.right = node;
        } else {
            parent.left = node;
        } 
        node.parent = parent;

这里需要注意的是把新插入的结点的父亲节点引用更新

调节平衡因子

接着上面的，我们新插入了一个结点node，那么肯定就要向上调整平衡因子了嘛，要一直从该node节点调整到根节点的平衡因子，直到这棵树平衡了。
走到这里，我们看上面代码走到，此时parent == node.parent ,cur ==null,我们让cur=node;接着往下看
如果cur是parent的左孩子，那么parent的bf就需要-1（因为左子树高度增加了）；如果cur是parent的右孩子，那么parent的bf就需要+1,(因为右子树高度增加了）,那么在向上更新的过程中，有三种情况：
第一种情况当parent.bf 等于0时，此时这棵树已经平衡，看图
在这里插入图片描述
第二中情况当parent.bf等于1或者-1时，此时就还要继续向上调整平衡因子
在这里插入图片描述
**第三种情况，当parent.bf == 2||parent.bf == -2的时候，那么此时这棵树就不平衡了，我们就要进行旋转，此时有4种情况，我们先把大致框架的代码先写出来：

//调节平衡因子
        while(parent!=null) {
            if(parent.left==cur) {
                parent.bf--;
            } else {
                parent.bf++;
            }
            if(parent.bf==0) {
                break;
            } else if(parent.bf==1||parent.bf==-1) {
                cur = parent;
                parent = cur.parent;
            } else {
                if(parent.bf==2) {
                    if(cur.bf==1) {
                        rotateLeft(parent);
                    } else {
                        //cur.bf==-1
                        rotateRL(parent);
                    }
                } else {
                    //parent.bf==-2
                    if(cur.bf==1) {
                        rotateLR(parent);
                    } else {
                        //cur.bf==-1
                        rotateRight(parent);
                    }
                }
                //完成一次旋转之后就能够达成平衡，直接break
                break;
            }
        }

看到上面代码，我们知道，旋转有4种情况，这里我告诉你，分别是右旋，左旋，左右双旋和右左双旋

AVL旋转调整

接着上面
第一种情况，当parent.bf ==-1 && cur.bf == -1 时，要进行右旋
如图
在这里插入图片描述
把subL看成中心，然后parent绕着subL向右手边旋转，然后把subL的右孩子给parent的左孩子即可
这里有一个细节，右旋完后，我们还要处理更新parent.parent的孩子指向，这里称为pParent：
如果parent 就是根节点，那我们让root == subL，然后让root.parent = null即可
如果pParent.left == parent || pParent.right ==parent，那么就更新一下pParent的孩子指向，然后让subL.parent = pParent即可，看图：
在这里插入图片描述
然后在更新一下subL和parent和bf，在这种情况subL.bf = parent.bf =0;看上图就可以知道
但是还有一种情况当subLR为null时，但是这种情况还是subL.bf = parent.bf =0，看图：
在这里插入图片描述

那么看一下右旋代码的实现：

    private void rotateRight(TreeNode parent) {
        TreeNode subL = parent.left;
        TreeNode subLR=subL.right;
        //记录一下parent的父亲节点
        TreeNode pParent = parent.parent;
        parent.left = subLR;
        //检查有没有subLR
        if(subLR!=null) {
            subLR.parent = parent;
        }
        subL.right = parent;
        parent.parent = subL;
        //检查当前是不是根节点
        if(parent == root) {
            root = subL;
            root.parent = null;
        } else {
            //不是根节点，判断这棵子树是左子树还是右子树
            if(pParent.left == parent) {
                pParent.left = subL;
            } else {
                pParent.right = subL;
            }
            subL.parent = pParent;
        }
        //更新平衡因子
        subL.bf = parent.bf = 0;
    }

第二种情况，当parent .bf=2 && cur.bf==1,要进行左旋
在这里插入图片描述

以subR为中心，让parent绕subR向左手边转，然后把subR的左孩子subRL给parent，然后把subR.bf = parent.bf=0，这里细节跟上面右旋差不多，就偷懒一下，直接看代码吧

private void rotateLeft(TreeNode parent) {
        TreeNode subR = parent.right;
        TreeNode subRL = subR.left;
        //记录一下parent的父亲节点
        TreeNode pParent = parent.parent;
        parent.right = subRL;
        //检查有没有subRL
        if(subRL!=null) {
            subRL.parent = parent;
        }
        subR.left = parent;
        parent.parent = subR;
        //检查当前是不是根节点
        if(parent==root) {
            root = subR;
            root.parent = null;
        } else {
            if(pParent.left == parent) {
                pParent.left = subR;
            } else {
                pParent.right = subR;
            }
            subR.parent = pParent;
        }
        //更新平衡因子
        subR.bf = parent.bf=0;
    }

第三种情况，当parent.bf==-2&&cur == 1，此时要进行左右双旋：
直接看图：
在这里插入图片描述
在这里插入图片描述
前面左旋，右旋都讲过了，这里就再偷懒一下，那么为什么我要画两幅图呢？
那当然是有原因的，你可以发现当插入的结点插入在subLR的左子树时(subLR.bf == -1)，和当插入的结点插入在subLR的右子树时(当subLR.bf == 1)，parent,subL,subLR的bf更新值是不一样的，所以共有三种情况，为什么两幅图会有三种情况呢，因为有一种情况不用处理

  • 当subLR.bf == -1，最终的平衡因子更新为：subLR = 0,subL=0,parent = 1
  • 当subLR.bf == 1，最终的平衡因子更新为：subLR= 0,subL = -1,parent =0
  • 当subLR.bf == 0 ,不用处理，这三点的bf值不会改变
    看代码：
private void rotateLR(TreeNode parent) {
        TreeNode subL = parent.left;
        TreeNode subLR = subL.right;
        int bf = subLR.bf;
        rotateLeft(parent.left);
        rotateRight(parent);
        //分情况调整，平衡因子
        if(bf==-1) {
            subL.bf=0;
            subLR.bf=0;
            parent.bf=1;
        } else if(bf==1) {
            subL.bf=-1;
            subLR.bf=0;
            parent.bf=0;

        }
        //当bf==0不需要做任何处理
    }

第四种情况就是，parebt.bf==2&& cur.bf ==-1，要使用右左双旋
还是一样，先看图
在这里插入图片描述

在这里插入图片描述
同样的右旋，左旋同样bf有三种情况

  • 当subRL.bf == -1，更新平衡因子，sunRL.bf=0,parent.bf =0,subR.bf=1
  • 当subRL.bf == 1，更新平衡因子，parent.bf = -1，subR.bf =0，subRL.bf=0
  • 当subRL.bf==0，不用处理
    看代码
 private void rotateRL(TreeNode parent) {
        TreeNode subR = parent.right;
        TreeNode subRL = subR.left;
        int bf = subRL.bf;
        rotateRight(parent.right);
        rotateLeft(parent);
        if(bf==-1) {
            subR.bf=1;
            subRL.bf=0;
            parent.bf=0;
        } else if(bf==1) {
            subR.bf = 0;
            subRL.bf = 0;
            parent.bf = -1;
        }
        //bf==0不需要处理
    }

写个isBalance验证一下是不是AVL树

public boolean isBalance(TreeNode root) {
        if(root == null) {
            return true;
        }
        int leftH = height(root.left);
        int rightH = height(root.right);
        if(rightH-leftH!=root.bf) {
            System.out.println("平衡因子异常 "+root.val);
            return false;
        }
        return Math.abs(rightH-leftH)<=1&&isBalance(root.left)&&isBalance(root.right);

    }

完整代码

package AVLTree;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: ling
 * Date: 2022-11-22
 * Time: 10:34
 */
public class AVLTree {
    static class TreeNode {
        public int val;//值
        public int bf;//平衡因子(右子树高度-左子树高度）
        public TreeNode left;//左孩子引用
        public TreeNode right;//右孩子引用
        public TreeNode parent;//父亲节点的引用

        public TreeNode(int val) {
            this.val = val;
        }
    }
    public TreeNode root;//根节点

    public boolean insert(int val) {
        TreeNode node = new TreeNode(val);
        if(root == null) {
            root = node;
            return true;
        }
        TreeNode parent = null;
        TreeNode cur = root;
        while(cur!=null) {
            if(cur.val<val) {
                parent = cur;
                cur= cur.right;
            } else if(cur.val==val) {
                return false;
            } else {
                parent = cur;
                cur = cur.left;
            }
        }
        //cur==null
        if(parent.val<val) {
            parent.right = node;
        } else {
            parent.left = node;
        }
        node.parent = parent;
        cur = node;
        //调节平衡因子
        while(parent!=null) {
            if(parent.left==cur) {
                parent.bf--;
            } else {
                parent.bf++;
            }
            if(parent.bf==0) {
                break;
            } else if(parent.bf==1||parent.bf==-1) {
                cur = parent;
                parent = cur.parent;
            } else {
                if(parent.bf==2) {
                    if(cur.bf==1) {
                        rotateLeft(parent);
                    } else {
                        //cur.bf==-1
                        rotateRL(parent);
                    }
                } else {
                    //parent.bf==-2
                    if(cur.bf==1) {
                        rotateLR(parent);
                    } else {
                        //cur.bf==-1
                        rotateRight(parent);
                    }
                }
                //完成一次旋转之后就能够达成平衡，直接break
                break;
            }
        }
        return true;
    }

    /**
     * 右左双旋
     * @param parent
     */
    private void rotateRL(TreeNode parent) {
        TreeNode subR = parent.right;
        TreeNode subRL = subR.left;
        int bf = subRL.bf;
        rotateRight(parent.right);
        rotateLeft(parent);
        if(bf==-1) {
            subR.bf=1;
            subRL.bf=0;
            parent.bf=0;
        } else if(bf==1) {
            subR.bf = 0;
            subRL.bf = 0;
            parent.bf = -1;
        }
        //bf==0不需要处理
    }
    /**
     * 左右双旋
     * @param parent
     */
    private void rotateLR(TreeNode parent) {
        TreeNode subL = parent.left;
        TreeNode subLR = subL.right;
        int bf = subLR.bf;
        rotateLeft(parent.left);
        rotateRight(parent);
        //分情况调整，平衡因子
        if(bf==-1) {
            subL.bf=0;
            subLR.bf=0;
            parent.bf=1;
        } else if(bf==1) {
            subL.bf=-1;
            subLR.bf=0;
            parent.bf=0;

        }
        //当bf==0不需要做任何处理
    }

    /**
     * 左单旋
     * @param parent
     */
    private void rotateLeft(TreeNode parent) {
        TreeNode subR = parent.right;
        TreeNode subRL = subR.left;
        //记录一下parent的父亲节点
        TreeNode pParent = parent.parent;
        parent.right = subRL;
        //检查有没有subRL
        if(subRL!=null) {
            subRL.parent = parent;
        }
        subR.left = parent;
        parent.parent = subR;
        //检查当前是不是根节点
        if(parent==root) {
            root = subR;
            root.parent = null;
        } else {
            if(pParent.left == parent) {
                pParent.left = subR;
            } else {
                pParent.right = subR;
            }
            subR.parent = pParent;
        }
        //更新平衡因子
        subR.bf = parent.bf=0;
    }

    /**
     * 右单旋
     * @param parent
     */
    private void rotateRight(TreeNode parent) {
        TreeNode subL = parent.left;
        TreeNode subLR=subL.right;
        //记录一下parent的父亲节点
        TreeNode pParent = parent.parent;
        parent.left = subLR;
        //检查有没有subLR
        if(subLR!=null) {
            subLR.parent = parent;
        }
        subL.right = parent;
        parent.parent = subL;
        //检查当前是不是根节点
        if(parent == root) {
            root = subL;
            root.parent = null;
        } else {
            //不是根节点，判断这棵子树是左子树还是右子树
            if(pParent.left == parent) {
                pParent.left = subL;
            } else {
                pParent.right = subL;
            }
            subL.parent = pParent;
        }
        //更新平衡因子
        subL.bf = parent.bf = 0;
    }

    /**
     * 验证是否为二叉平衡树
     * @param root
     * @return
     */
    public boolean isBalance(TreeNode root) {
        if(root == null) {
            return true;
        }
        int leftH = height(root.left);
        int rightH = height(root.right);
        if(rightH-leftH!=root.bf) {
            System.out.println("平衡因子异常 "+root.val);
            return false;
        }
        return Math.abs(rightH-leftH)<=1&&isBalance(root.left)&&isBalance(root.right);

    }
    /**
     * 求树的高度
     */
    private int height(TreeNode root) {
        if(root == null) {
            return 0;
        }
        int leftH =height(root.left);
        int rightH = height(root.right);
        return leftH>rightH?leftH+1:rightH+1;
    }


    public static void main(String[] args) {
        AVLTree avlTree1 = new AVLTree();
        AVLTree avlTree2 = new AVLTree();
        int[] arr1 ={16, 3, 7, 11, 9, 26, 18, 14, 15};
        int[] arr2 ={4, 2, 6, 1, 3, 5, 15, 7, 16,14};
        for(int i=0;i<arr1.length;i++) {
            avlTree1.insert(arr1[i]);
        }
        System.out.println(avlTree1.isBalance(avlTree1.root));
        for(int i=0;i<arr2.length;i++) {
            avlTree2.insert(arr2[i]);
        }
        System.out.println(avlTree2.isBalance(avlTree2.root));
    }
}
迷宫白
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
自平衡二叉树（AVL）及四种旋转方式详解
weixin_49561506的博客
05-30 1565
介绍AVL树的概念，以及AVL树旋转的四种方式
AVL树的旋转操作详解
张小凡
09-18 2143
图解AVL平衡二叉树的旋转
AVL树--单旋转、双旋转与实现
iEucliwood的博客
12-29 1023
AVL树 AVL（Adelson-Velskii andLandis）树是带有平衡条件的二叉查找树。必须保证树的深度是。 最简单的想法是要求左右子树具有相同的高度。 另一种平衡条件是要求每个节点都必须要有相同高度的左子树和右子树。如果空子树的高度定义为-1（通常就是这么定义的），那么只有具有个节点的理想平衡树（perfectly balanced tree）满足这个条件。因此虽然这种平衡条件保证了树的深度小，但是它太严格，难以使用需要放...
【AVL树】双旋转，插入以及删除
weixin_52958292的博客
11-25 148
并且当存在左子树或者右子树，插入新的结点到左子树或者右子树，当前插入节点的parent的高度不会发生变化。原因：因为插入一个新的结点不会使树的高度加2，只会让树的高度加1.并且平衡因子最大为2，最小为-2.AVL树再平衡后，在插入新的节点后，不需要在进行回溯和调平。平衡因子小于0（-1），往右边的树插入。平衡因子大于0（1），往左边树插入。大于0进行左单旋，小于0进行右单选。
AVL树添加节点后的平衡操作（一）逻辑分析：左旋、右旋、双旋（超详细图解）
Demon_LMMan的博客
03-15 2748
AVL树 AVL树是最早发明的自平衡二叉搜索树之一，其名字来源于两位发明它的科学家G. M. Adelson-Velsky 和 E. M. Landis（来自苏联的科学家）。 AVL树的特点 AVL树中的每个节点都有一个平衡因子（Balance Factor），即左右子树高度之差。AVL树的特点如下： 每个节点的平衡因子只可能是 1、0、-1（绝对值 ≤ 1，如果超过 1，称之为“失衡“） 每个节点的左右子树高度差不超过1 搜索、添加、删除的时间复杂度是O(logn) 在AVL树中添加节点 假如我们对下
AVL-tree.zip_AVL高效实现_avl 旋转_二叉树旋转_树 旋转
09-19
在本资料包中，"AVL tree"文件包含了关于AVL树高效实现和旋转的详细内容。 首先，AVL树的平衡条件确保了查找操作的时间复杂度为O(log n)，其中n是树中节点的数量。这是通过在每次插入或删除节点后进行旋转操作来...
avl.rar_AVL树_avl 旋转_树 旋转
09-24
在"avl.rar"压缩包中的"main.cpp"文件，很可能是实现了一个AVL树的C++程序，包括查找、删除以及上述四种旋转操作的代码。通过直接运行这个程序，我们可以观察和理解AVL树的各种操作是如何在实际中执行的。查找操作...
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
基于Qt和Avl树实现登录系统【100013012】
07-19
通过实现这样一个登录系统，学生可以深入理解Qt的图形界面设计和Avl树的数据结构及其应用，同时锻炼到软件工程中的需求分析、设计、编码和测试等各个环节。 总结来说，这个项目结合了GUI开发和数据结构两大主题，...
AVL树的单旋转双旋转
weixin_42304745的博客
07-27 3637
【0】README 0.0） 本文部分idea 转自：http://blog.csdn.net/collonn/article/details/20128205 0.1） 本文专注于 解析 AVL 树的 单旋转（左左单旋转和右右单旋转） 和 双旋转（左右双旋转和右左单旋转）的内部核心技巧（历时一天吧，估计）； 0.2） 不得不提的是， 旋转有两个属性： 轴 和 旋转方向； 0.3） 201601...
AVL树节点插入方式解析（单旋转和双旋转）
最新发布
D223546的博客
11-07 161
此时的抽象图就是对实际情况的归类，但是实际情况是存在无数种的，因为h可以等于0，1，2，3，4，5，6.当h等于2的时候，AVL树都存在三种，以下的三种都是可以放到abc，那三个位置的。但是这样打印出来一个升序的结果，只能证明这是一个搜索树，不能证明这一个AVL树，所以我们还需要些一个验证平衡的代码，即求出每一个节点的左右高度差（右子树高度减去左子树高度），如果不等于平衡因子，则证明我们的AVL树出现了错误。我们分开是因为虽然旋转的过程是一样的，到那时需要按照不同的情况，去处理不同的平衡因子。
AVL树的左旋右旋、计算高度以及判断是否完全
Keep Fighting!
07-16 1415
#include &lt;iostream&gt; #include &lt;vector&gt; #include &lt;queue&gt; using namespace std; struct node{ int val; struct node *left,*right; }; node* leftRotate(node *tree){ node *temp = tree-...
图示讲解AVL平衡二叉树的左旋和右旋
江城的博客
07-22 2万+
AVLTree 高度平衡的搜索二叉树 一棵平衡树，或是空树，或是具有以下性质的二叉搜索树：左子树和右子树都是AVL树，且左右子树的高度之差的绝对值不超过1。 该二叉树，根结点的右子树高度为3，左子树高度为2。结点上方的数字为平衡因子，因为右子树高度比左子树高度大1，所以根结点的平衡因子为1。 一颗平衡二叉树，如果有n个结点，其高度可保持O(log2^n),平均搜索长度也可以保持在O(l...
浅析AVL树--AVL树的双旋转
一只巴扎黑的博客
02-19 784
潜析AVL树–AVL树的双旋转 接上篇博文：简析AVL树–AVL树的概念及单旋转 AVL树如何恢复平衡之双旋转 首先假设我们有一颗已经处于平衡的AVL树： 上篇博文已经解决了LL和RR两种情况的平衡恢复解决方案----单旋转。这篇博文来看双旋转情形。这时候我们插入结点7，我们可以发现这时这棵树并没有失去平衡： 但是，如果我们继续插入结点8，这棵树就会再次处于失衡状态： 我们首先可以发现结点9...
【C++】 --AVL树的双旋
Vicky_Cr的博客
02-19 299
这个先贴一个之前写的博客，是关于左旋和右旋的https://blog.csdn.net/Vicky_Cr/article/details/104375075，这篇博客是对上一节的补充，在增加节点的时候，存在单旋和双旋，本篇文章主要介绍双旋 AVL树的双旋 双旋分为左右双旋和右左双旋 左右单旋：左右双旋先左单旋，再右单旋，即就是先顺时针旋转，后逆时针旋转 void RotateLR(Node* p...
269-AVL树(左，右双旋转)
LINZEYU666的博客
04-13 430
AVL树(左，右双旋转) 我们依次插入数据结点56,90,67。最后形成了“折线”，所以我们要进行双旋转 我们依次插入数据结点78,34,45。最后形成了“折线”，所以我们要进行双旋转 我们要求的中序遍历是从小到大，旋转之后使得每个节点的平衡因子尽可能向0靠拢。 我们要借助左单旋转函数和右单旋转函数的能力来进行 我们把34和45，以45为基准，进行左单旋转，34放下来，45放上去，再以45位基准，把78进行右单旋转。 我们来看下面这个问题 (a)是平衡二叉树，我们可能在D或者F或者G插入数据，如果
AVL树的单双旋转解析
PacosonSWJTU的博客
01-15 7420
【0】README0.0） 本文部分idea 转自：http://blog.csdn.net/collonn/article/details/20128205 0.1） 本文专注于 解析 AVL 树的 单旋转（左左单旋转和右右单旋转） 和 双旋转（左右双旋转和右左单旋转）的内部核心技巧（历时一天吧，估计）； 0.2） 不得不提的是， 旋转有两个属性： 轴 和 旋转方向；【1】 如何判断进行单
AVL树的旋转图解和简单实现
热门推荐
喵了个呜的博客
07-07 4万+
AVL树是带有平衡条件的查找二叉树。这个平衡条件要容易保持，而且他要保证树的深度为O(logN) 原文地址：http://blog.csdn.net/qq_25806863/article/details/74755131 平衡条件 一个最理想的平衡条件是左右两个子树的高度完全相等，但只有节点数量为2^n-1的树才满足这个条件（n是层数，2层要3个，3层要7个）。这个条件太严格，不好用。...
数据结构：关于AVL树的平衡旋转详解
大鱼
12-28 2万+
前言 本文是基于你已经有一定的二叉排序树知识。如果你还是小白，可以参考我之前的博客：《数据结构：二叉搜索树（BST）的基本操作》。所以，在本文中不会再出现关于BST树的基本知识。 版权说明 著作权归作者所有。 商业转载请联系作者获得授权，非商业转载请注明出处。 作者：Q-WHai 发表日期： 2015年12月28日 链接：https://qwhai.blog.csdn.net/ar...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值