AVL树

最新推荐文章于 2023-11-11 10:05:02 发布
最新推荐文章于 2023-11-11 10:05:02 发布
阅读量129 收藏
点赞数
文章标签： 二叉树 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40920882/article/details/104657374
版权

平衡二叉树

平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树，且具有以下性质：

  • 本身首先是一棵二叉搜索树
  • 带有平衡条件：每个节点的左右子树的高度之差的绝对值（平衡因子）最多为1

也就是说，AVL树，本质上是带有平衡功能的二叉树（二叉排序树，二叉搜索树）
但AVL树也是一种特殊的二叉搜索树，在相对于数据极端情况下二叉搜索树会退化成单链表，AVL树定义旋转操作，在平衡因子大于2时，AVL树会旋转来调整树的结构，来满足平衡因子小于2
在这里插入图片描述
右边的是AVL树

AVL的结构

// AVL树的节点(内部类)
    class AVLTreeNode<T extends Comparable<T>> {
        T element;                // 值
        int height;         // 高度
        AVLTreeNode<T> left;    // 左孩子
        AVLTreeNode<T> right;    // 右孩子

        public AVLTreeNode(T key, AVLTreeNode<T> left, AVLTreeNode<T> right) {
            this.element = key;
            this.left = left;
            this.right = right;
            this.height = 0;
        }
    }

AVL的不平衡情况

AVL树大部分操作都和BST树相同, 只有在插入删除结点时, 有可能造成AVL树失去平衡, 而且只有那些在被插入/删除结点到根节点的路径上的结点有可能出现失衡, 因为只有那些结点的子树结构发生了变化

当插入新结点导致不平衡时, 我们需要找到距离新节点最近的不平衡结点为轴来转动AVL树来达到平衡

左子树的左节点插入节点（左左）

image

插入节点2，导致节点6失衡（节点2相对于节点6为左子树的左子树），那么就需要旋转6，使平衡因子重新满足AVL树的条件

/**
     * LL：左左对应的情况(左单旋转)。
     * @param k2
     * @return 旋转后的根节点
     */
    private AVLTreeNode<T> leftLeftRotation(AVLTreeNode<T> k2) {
        AVLTreeNode<T> k1;

        k1 = k2.left;
        k2.left = k1.right;
        k1.right = k2;

        k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
        k1.height = Math.max(height(k1.left), k2.height) + 1;

        return k1;
    }
右子树的右子树插入节点（右右）

image

 private AVLTreeNode<T> rightRightRotation(AVLTreeNode<T> k1) {
        AVLTreeNode<T> k2;

        k2 = k1.right;
        k1.right = k2.left;
        k2.left = k1;

        k1.height = Math.max(height(k1.left), height(k1.right)) + 1;
        k2.height = Math.max(height(k2.right), k1.height) + 1;

        return k2;
    }
左子树的右子树插入节点 (左右)

image

/**
     *  LR：左右对应的情况(左双旋转)。
     * @param k3
     * @return 旋转后的根节点
     */
    private AVLTreeNode<T> leftRightRotation(AVLTreeNode<T> k3) {
        k3.left = rightRightRotation(k3.left);

        return leftLeftRotation(k3);
    }
右子树的左子树插入节点 (右左)

image

 /**
     * RL：右左对应的情况(右双旋转)。
     * @param k1
     * @return 旋转后的根节点
     */
    private AVLTreeNode<T> rightLeftRotation(AVLTreeNode<T> k1) {
        k1.right = leftLeftRotation(k1.right);

        return rightRightRotation(k1);
    }
插入
 public void insert(T key) {
        mRoot = insert(mRoot, key);
    }

    /**
     * 将结点插入到AVL树中，并返回根节点
     *
     * @param tree AVL树的根结点
     * @param key  插入的结点的键值
     * @return 根节点
     */
    private AVLTreeNode<T> insert(AVLTreeNode<T> tree, T key) {
        if (tree == null) {
            // 新建节点
            return tree = new AVLTreeNode<T>(key, null, null);

        }

        int cmp = key.compareTo(tree.element);
        if (cmp < 0) {// 将key插入到"tree的左子树"的情况
            tree.left = insert(tree.left, key);

        } else if (cmp > 0) { // 将key插入到"tree的右子树"的情况
            tree.right = insert(tree.right, key);
        }

        return balance(tree);
    }
当失去平衡是通过balance（）进行调节
 private static final int ALLOWED_IMBALANCE = 1;

    private AVLTreeNode<T> balance(AVLTreeNode<T> tree) {
        if (tree == null) {
            return tree;
        }
        // 插入节点后，若AVL树失去平衡，则进行相应的调节。
        if (height(tree.left) - height(tree.right) > ALLOWED_IMBALANCE) {

            if (height(tree.left.left) >= height(tree.left.right)) {
                leftLeftRotation(tree);
            } else {
                leftRightRotation(tree);
            }
        } else if (height(tree.right) - height(tree.left) > ALLOWED_IMBALANCE) {
            if (height(tree.right.right) >= height(tree.right.left)) {
                rightRightRotation(tree);
            } else {
                rightLeftRotation(tree);
            }
        }
        tree.height = Math.max( height(tree.left), height(tree.right)) + 1;

        return tree;
    }
删除
public void remove(T key) {
        AVLTreeNode<T> z;

        mRoot = remove(mRoot, z);
    }

    /**
     * 删除结点(z)，返回根节点
     *
     * @param tree AVL树的根结点
     * @param z    待删除的结点
     * @return 根节点
     */
    private AVLTreeNode<T> remove(AVLTreeNode<T> tree, AVLTreeNode<T> z) {
        if (tree == null)
            return tree;

        int cmp = z.element.compareTo(tree.element);
        if (cmp > 0) {
            tree.right = remove(tree.right, z);
        } else if (cmp < 0) {
            tree.left = remove(tree.left, z);
        } else if (tree.left != null && tree.right != null) {
            tree.element = findMin(tree.right).element;
            tree.right = remove(tree.element, tree.right);
        } else {
            tree = (tree.left != null) ? tree.left : tree.right;
        }
        return balance(tree);
    }

    private AVLTreeNode<T> findMin(AVLTreeNode<T> node) {
        if (node != null) {
            while (node.left != null) {
                node = node.left;
            }
        }
        return node;
    }

    public AVLTreeNode<T> remove(T t, AVLTreeNode<T> node) {
        if (node == null) {
            return node;
        }
        int compareResult = t.compareTo(node.element);
        if (compareResult > 0) {
            node.right = remove(t, node.right);
        } else if (compareResult < 0) {
            node.left = remove(t, node.left);
        } else if (node.left != null && node.right != null) {
            node.element = findMin(node.right).element;
            node.right = remove(node.element, node.right);
        } else {
            node = (node.left != null) ? node.left : node.right;
        }
        return node;

    }

完整代码

public class AVLTree<T extends Comparable<T>> {

    private AVLTreeNode<T> mRoot;    // 根结点

    // AVL树的节点(内部类)
    class AVLTreeNode<T extends Comparable<T>> {
        T element;                // 值
        int height;         // 高度
        AVLTreeNode<T> left;    // 左孩子
        AVLTreeNode<T> right;    // 右孩子

        public AVLTreeNode(T key, AVLTreeNode<T> left, AVLTreeNode<T> right) {
            this.element = key;
            this.left = left;
            this.right = right;
            this.height = 0;
        }
    }

    /*
     * 获取树的高度
     */
    private int height(AVLTreeNode<T> tree) {
        if (tree != null)
            return tree.height;

        return 0;
    }

    public int height() {
        return height(mRoot);
    }

    /*
     * LL：左左对应的情况(左单旋转)。
     *
     * 返回值：旋转后的根节点
     */

    /**
     * LL：左左对应的情况(左单旋转)。
     *
     * @param k2
     * @return 旋转后的根节点
     */
    private AVLTreeNode<T> leftLeftRotation(AVLTreeNode<T> k2) {
        AVLTreeNode<T> k1;

        k1 = k2.left;
        k2.left = k1.right;
        k1.right = k2;

        k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
        k1.height = Math.max(height(k1.left), k2.height) + 1;

        return k1;
    }

    /**
     * 右右对应的情况(右单旋转)。
     *
     * @param k1
     * @return 旋转后的根节点
     */
    private AVLTreeNode<T> rightRightRotation(AVLTreeNode<T> k1) {
        AVLTreeNode<T> k2;

        k2 = k1.right;
        k1.right = k2.left;
        k2.left = k1;

        k1.height = Math.max(height(k1.left), height(k1.right)) + 1;
        k2.height = Math.max(height(k2.right), k1.height) + 1;

        return k2;
    }


    /**
     * LR：左右对应的情况(左双旋转)。
     *
     * @param k3
     * @return 旋转后的根节点
     */
    private AVLTreeNode<T> leftRightRotation(AVLTreeNode<T> k3) {
        k3.left = rightRightRotation(k3.left);

        return leftLeftRotation(k3);
    }

    /**
     * RL：右左对应的情况(右双旋转)。
     *
     * @param k1
     * @return 旋转后的根节点
     */
    private AVLTreeNode<T> rightLeftRotation(AVLTreeNode<T> k1) {
        k1.right = leftLeftRotation(k1.right);

        return rightRightRotation(k1);
    }


    public void insert(T key) {
        mRoot = insert(mRoot, key);
    }

    /**
     * 将结点插入到AVL树中，并返回根节点
     *
     * @param tree AVL树的根结点
     * @param key  插入的结点的键值
     * @return 根节点
     */
    private AVLTreeNode<T> insert(AVLTreeNode<T> tree, T key) {
        if (tree == null) {
            // 新建节点
            return tree = new AVLTreeNode<T>(key, null, null);

        }

        int cmp = key.compareTo(tree.element);
        if (cmp < 0) {// 将key插入到"tree的左子树"的情况
            tree.left = insert(tree.left, key);

        } else if (cmp > 0) { // 将key插入到"tree的右子树"的情况
            tree.right = insert(tree.right, key);
        }

        return balance(tree);
    }


    private static final int ALLOWED_IMBALANCE = 1;

    private AVLTreeNode<T> balance(AVLTreeNode<T> tree) {
        if (tree == null) {
            return tree;
        }
        // 插入节点后，若AVL树失去平衡，则进行相应的调节。
        if (height(tree.left) - height(tree.right) > ALLOWED_IMBALANCE) {

            if (height(tree.left.left) >= height(tree.left.right)) {
                leftLeftRotation(tree);
            } else {
                leftRightRotation(tree);
            }
        } else if (height(tree.right) - height(tree.left) > ALLOWED_IMBALANCE) {
            if (height(tree.right.right) >= height(tree.right.left)) {
                rightRightRotation(tree);
            } else {
                rightLeftRotation(tree);
            }
        }
        tree.height = Math.max(height(tree.left), height(tree.right)) + 1;

        return tree;
    }

    public void remove(T key) {
        AVLTreeNode<T> z;

        if ((z = search(mRoot, key)) != null)
            mRoot = remove(mRoot, z);
    }

    /*
     * (递归实现)查找"AVL树x"中键值为key的节点
     */
    private AVLTreeNode<T> search(AVLTreeNode<T> x, T key) {
        if (x == null)
            return x;

        int cmp = key.compareTo(x.element);
        if (cmp < 0)
            return search(x.left, key);
        else if (cmp > 0)
            return search(x.right, key);
        else
            return x;
    }

    public AVLTreeNode<T> search(T key) {
        return search(mRoot, key);
    }

    /**
     * 删除结点(z)，返回根节点
     *
     * @param tree AVL树的根结点
     * @param z    待删除的结点
     * @return 根节点
     */
    private AVLTreeNode<T> remove(AVLTreeNode<T> tree, AVLTreeNode<T> z) {
        if (tree == null)
            return tree;

        int cmp = z.element.compareTo(tree.element);
        if (cmp > 0) {
            tree.right = remove(tree.right, z);
        } else if (cmp < 0) {
            tree.left = remove(tree.left, z);
        } else if (tree.left != null && tree.right != null) {
            tree.element = findMin(tree.right).element;
            tree.right = remove(tree.element, tree.right);
        } else {
            tree = (tree.left != null) ? tree.left : tree.right;
        }
        return balance(tree);
    }

    private AVLTreeNode<T> findMin(AVLTreeNode<T> node) {
        if (node != null) {
            while (node.left != null) {
                node = node.left;
            }
        }
        return node;
    }

    public AVLTreeNode<T> remove(T t, AVLTreeNode<T> node) {
        if (node == null) {
            return node;
        }
        int compareResult = t.compareTo(node.element);
        if (compareResult > 0) {
            node.right = remove(t, node.right);
        } else if (compareResult < 0) {
            node.left = remove(t, node.left);
        } else if (node.left != null && node.right != null) {
            node.element = findMin(node.right).element;
            node.right = remove(node.element, node.right);
        } else {
            node = (node.left != null) ? node.left : node.right;
        }
        return node;

    }

    /*
     * 打印"二叉查找树"
     *
     * key        -- 节点的键值
     * direction  --  0，表示该节点是根节点;
     *               -1，表示该节点是它的父结点的左孩子;
     *                1，表示该节点是它的父结点的右孩子。
     */
    private void print(AVLTreeNode<T> tree, T key, int direction) {
        if(tree != null) {
            if(direction==0)    // tree是根节点
                System.out.printf("%2d is root\n", tree.element, key);
            else                // tree是分支节点
                System.out.printf("%2d is %2d's %6s child\n", tree.element, key, direction==1?"right" : "left");

            print(tree.left, tree.element, -1);
            print(tree.right,tree.element,  1);
        }
    }

    public void print() {
        if (mRoot != null)
            print(mRoot, mRoot.element, 0);
    }
}

完整测试代码

public class AVLTreeTest {
    private static int arr[] = {3, 2, 1, 4, 5, 6, 7, 16, 15, 14, 13, 12, 11, 10, 8, 9};

    public static void main(String[] args) {
        int i;
        AVLTree<Integer> tree = new AVLTree<Integer>();

        System.out.printf("== 依次添加: ");
        for (i = 0; i < arr.length; i++) {
            System.out.printf("%d ", arr[i]);
            tree.insert(arr[i]);
        }

        System.out.printf("== 高度: %d\n", tree.height());
        System.out.printf("== 树的详细信息: \n");
        tree.print();

        i = 6;
        System.out.printf("\n== 删除根节点: %d", i);
        tree.remove(i);

        System.out.printf("\n== 高度: %d", tree.height());
        System.out.printf("\n== 树的详细信息: \n");
        tree.print();
    }
}
AlexNii
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构】AVL树——平衡二叉排序树（C语言）
moX980的博客
07-24 406
AVL树——平衡二叉排序树性质调整操作AVL树-左旋AVL树右旋失衡类型LL/RRLR/RL代码演示 性质 当一棵普通的二叉排序树是右边这个样子，树–>链表 那么二叉树的查找效率就由O(logn)退化成了O(n) 右边的树是不平衡的，下面介绍一种平衡二叉排序树——AVL树 AVL树的平衡条件：节点左右子树的高度差<=1 上述条件保证树不会退化成链表 高度h的BS树节点个数 h<=n<=2h-1 高度为h的AVL树节点个数1.5h<=n<=2h-1 low(h) =
数据结构篇——平衡二叉树（AVL树）
CZC1999的博客
11-06 369
引入 上一篇写了二叉排序树，构建一个二叉排序树，如果构建序列是完全有序的，则会出现这样的情况： 显然这种情况会使得二叉搜索树退化成链表。当出现这样的情况，二叉排序树的查找也就退化成了线性查找，所以我们需要合理调整二叉排序树的形态，使得树上的每个结点都尽量有两个子结点，这样整个二叉树的高度就会大约在\(log(n)\) 左右，其中 \(n\) 为结点个数。 基本性质 ​ AVL树也称为...
平衡二叉树（AVL树，一种二叉排序树）
一个搬运知识的笨小孩
08-29 1216
平衡二叉树 下面的图片来自教材《大话数据结构》 以下二叉排序树和右斜树的查找效率不是最高的，引出平衡二叉树来提高查找效率 平衡二叉树是一种二叉排序树，其中每一个结点的左子树和右子树的高度差至多为1 平衡因子BF（Balance Factor）=== 结点的左子树高度 −-− 结点的右子树高度 平衡二叉树上所有结点的BF只可能是{−1,0，1}\{-1,0，1\}{−1,0，1} 1.判断是否为平衡二叉树 图2中59大于58不满足二叉排序树，故不可能是平衡二叉树 图3中结点58的左子树高度为3，结点58的
[数据结构与算法-17]二叉排序树和平衡二叉树（AVL）
学哥斌的博客
04-18 635
文章目录1、二叉排序树1.1 介绍1.2 二叉排序树的删除1.2.1 可能的情况1.2.1 代码解决流程1.3 删除的代码实现2、平衡二叉树2.1 问题的提出2.2 介绍2.3 左旋2.4 右旋 1、二叉排序树 1.1 介绍   二叉排序树是二叉树的一种，对于任何一个非叶子结点，要求左子结点的值比当前结点值小，右子结点比当前结点的值大。   特别说明：如果有相同的值，可以放在左子结点或右子结点。 ...
AVL树（平衡二叉树）
qq_29651765的博客
12-19 376
概念：是一种二叉排序树，又称平衡二叉树，其中每一个节点的左子树和右子树的高度相差至多等于1。 平衡因子：树上节点的左子树的深度减去右子树的深度的值。 树上所有节点中，如果有一个节点的平衡因子的绝对值大于1 ，树就失去了平衡。 最小不平衡子树：距离插入节点最近的，且平衡因子的绝对值大于1的节点为根的子树。 左转，右转：当树失去平衡后，我们可以通过节点的旋转来使其达到平衡。   例：有一棵...
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
AVL.rar_AVL树
09-21
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树，AV是两位发明者姓名的首字母。这种数据结构在进行插入和删除操作后能自动调整...
DataStructures - 05：二叉排序树与AVL树
你今天真好看呀
04-04 258
文章目录1、二叉排序树BST1.1 创建二叉排序树并遍历1.2 二叉排序树删除节点2、平衡二叉排序树AVL树2.1 左旋转2.2 右旋转2.3 双旋转 1、二叉排序树BST Binary Sort Tree：对于二叉排序树的任何一个非叶子节点，要求其左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。 1.1 创建二叉排序树并遍历 将一个数组创建成对应的二叉排序树，并使用中序遍历二叉排序...
【我是一棵树】二叉排序树、平衡二叉树（AVL）
不了痕的博客
01-22 1008
二叉排序树 又称为二叉查找树。它或者是一棵空树，或者是具有下列性质的二叉树： 若他的左子树不空，则左子树上所有节点的值均小于它根节点的值 若他的右子树不空，则右子树上所有节点的值均大于根节点的值 它的左、右子树也分别为二叉排序树 二叉排序树特点 是以链接的方式存储，保持了链接存储结构在执行插入或删除操作室，不用一栋元素的优点，只要找到合适的插入和删除位置后，仅需修改链接指针即可。插入、删...
数据结构之树（3）——二叉平衡树（AVL）
二木成林
02-23 2144
AVL树 AVL树即是平衡二叉树，是一种特殊的二叉排序树。 它的左右子树都是平衡二叉树，并且左右子树的高度之差的绝对值不超过1。 注意：平衡二叉树就是一棵二叉排序树，是二叉排序树的改进，提高了查找效率。 AVL树的插入结点根二叉排序树是一样的，都是遵循左小右大的原则。 但在插入过程中，每插入一个新的结点，就需要检查新结点的插入是否使得原平衡二叉树失去平衡，如果失去平衡则需要进行平衡调整。 为了判断一棵二叉排序树是否是平衡二叉树，引进了平衡因子的概念。平衡因子是针对树中的结点来说的，一个结点的平衡
【数据结构】二叉排序树，AVL树，B，B+树总结
mengaliu_123的博客
09-24 1400
二叉排序树简介： 二叉排序树是对普通二叉树的基础上对根、左、右结点做了关键字大小上的限制。优点 在查找时可根据左右子节点与根节点的大小关系进行，减少顺序查找的时间复杂度。缺点： 由于一个排序序列转化成一颗二叉排序树，有多种形式。因此，在某些情况下，二叉排序树的查找时间复杂度不可估量，在最坏的情况下，退化成顺序查找的情况。AVL树简介： AVL树是在二叉排序树的基础上增加了平衡因子的概念，对每
二叉树，二叉搜索树，AVL树，红黑树。学习笔记
CrankZ的博客
10-23 969
树的基本概念 维基百科对树的分类 树的基本概念与术语 在计算器科学中，树（英语：tree）是一种抽象数据类型（ADT）或是实现这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n&gt;0）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 每个节点有零个或多个子节点； 没有父节...
算法整理：查找篇-二叉排序树&&AVL树
ReDreamme的博客
08-31 705
本文主要介绍二叉排序树、平衡二叉树的查找、插入、删除及相关代码。
二叉搜索树及AVL
ZergWang's Blog
11-30 663
二叉搜索树（Binary Search Tree） 又称二叉排序树，对于此树中的任一节点，其左子树所有节点的值都比该节点小，其右子树所有节点都比该节点大。因此，该树的中序遍历会得到一个有序序列。 平衡二叉搜索树 B树 B+树 红黑树 ...
BST（二叉搜索树）转AVL（平衡二叉树）
qq_38292933的博客
08-23 1527
有了之前的BST，我们再其基础上，进行小小的改动即可形成平衡二叉树。 先看二叉平衡树的定义： 具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 要实现它， 首先我们需要为节点，entry新增加一个属性，表示节点的高度，int high。 之后，由于要对树进行自底向上的回溯，检查平衡因子是否符合标准。且我们不存在父节点，故需要一个辅助栈记录我...
数据结构:AVL树详解(平衡二叉树)
最新发布
机会是给有准备的人
11-11 3426
假如以 parent 为根的子树不平衡，即 parent 的平衡因子为2或者-2，分以下情况考虑parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR当subR的平衡因子为1时，执行左单旋当subR的平衡因子为-1时，执行右左双旋parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL当subL的平衡因子为-1是，执行右单旋当subL的平衡因子为1时，执行左右双旋。
二叉排序树、红黑树、AVL树最简单的理解
热门推荐
linshijun33的专栏
12-04 1万+
前言[为什么写这篇]之前在知乎上看过一个提问：为什么红黑树比AVL树用的场景更为广泛，红黑树在 STL 和 Linux 都有一定的运用。而AVL树也在 Windows进程地址空间管理 中得到了使用。既然红黑树和AVL树这么厉害，就要进一步了解一下它们到底是什么。基础准备[需要懂点数据结构哦]红黑树和AVL都是来源于二叉排序树，关于二叉搜索树的相关知识本文将会对一些简单的概念和操作进行分析，更多的细节
二叉排序树和AVL树
qq_51340322的博客
08-28 1224
二叉排序树和AVL树 文章目录二叉排序树和AVL树一、二叉排序树1. 理论定义(1)、什么是二叉排序树(2)、简单介绍二叉排序树2. 模拟画图3. 要点分析4. 代码实现(1)、定义结构体：(2)、插入新节点：(3)、层序遍历：(4)、中序遍历：中序遍历二叉排序树可得到有序序列(5)、完整代码：二、AVL树1. 理论定义2. 模拟旋转3. 代码实现 引言：本文视频链接全部来自bilibili，因为是在bilibili大学上学qwq 一、二叉排序树 1. 理论定义 (1)、什么是二叉排序树 ​
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值