第八章 平衡二叉搜索树、AVL树

已于 2022-03-17 22:21:04 修改
阅读量717 收藏 2
点赞数 3
分类专栏： 恋上数据结构与算法 第一季 文章标签： 数据结构 算法 平衡二叉树 AVL树 leetcode
于 2022-03-17 22:19:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sj15814963053/article/details/123562477
版权

第八章 平衡二叉搜索树、AVL树

二叉搜索树缺点分析

Untitled

  • 当 n 比较大时，两者的性能差异比较大
  • 比如 n = 1000000 时，二叉搜索树的最低高度是 20，最高高度是 1000000

由此可见，

二叉搜索树添加节点时可能会导致二叉搜索树退化成链表

删除节点时也可能会导致二叉搜索树退化成链表

有没有办法防止二叉搜索树退化成链表？

让添加、删除、搜索的复杂度维持在 O(logn)？

改进二叉搜索树

平衡（Balance）

平衡：当节点数量固定时，左右子树的高度越接近，这棵二叉树就越平衡（高度越低）

Untitled

理想平衡

最理想的平衡，就是像完全二叉树、满二叉树那样，高度是最小的

Untitled

如何改进二叉搜索树？

  • 首先，节点的添加、删除顺序是无法限制的，可以认为是随机的
  • 所以，改进方案是：在节点的添加、删除操作之后，想办法让二叉搜索树恢复平衡（减小树的高度）

Untitled

  • 如果接着继续调整节点的位置，完全可以达到理想平衡，但是付出的代价可能会比较大
    • 比如调整的次数会比较多，反而增加了时间复杂度
  • 总结来说，比较合理的改进方案是：用尽量少的调整次数达到适度平衡即可
  • 一棵达到适度平衡的二叉搜索树，可以称之为：平衡二叉搜索树

平衡二叉搜索树（Balanced Binary Search Tree）

  • 英文简称为：BBST
  • 经典常见的平衡二叉搜索树有：
    • AVL树
      • Windows NT 内核中广泛使用
    • 红黑树
      • C++ STL（比如 map、set ）
      • Java 的 TreeMap、TreeSet、HashMap、HashSet
      • Linux 的进程调度
      • Ngix 的 timer 管理
    • 一般也称它们为：自平衡的二叉搜索树（Self-balancing Binary Search Tree）

AVL树

  • AVL 树是最早发明的自平衡二叉搜索树之—
  • AVL取名于两位发明者的名字
    • G.M.Adelson-Velsky 和 E.M.Landis（来自苏联的科学家）
  • 平衡因子（Balance Factor）：某结点的左右子树的高度差
  • AVL树的特点：
    • 每个节点的平衡因子只可能是 1、0、-1 (绝对值 ≤ 1，如果超过 1，称之为 “失衡")
    • 每个节点的左右子树高度差不超过1
    • 搜索、添加、删除的时间复杂度是 O ( logn )

Untitled

BST 对比 AVLTree

输入数据：35, 37, 34, 56, 25, 62, 57, 9, 74, 32, 94, 80, 75, 100, 16, 82

Untitled

继承 BST

Untitled

添加节点导致的失衡

示例：往下面这棵子树中添加 13

  • 最坏情况：可能会导致所有祖先节点都失衡
  • 父节点、非祖先节点，都不可能失衡

Untitled

修复平衡的操作：

  • LL – 右旋转（单旋）
  • RR – 左旋转（单旋）
  • LR – 先左旋，再右旋（双旋）
  • RL – 先右旋，再左旋（双旋）

有些教程里面：

  • 把右旋转叫做 zig，旋转之后的状态叫做 zigged
  • 把左旋转叫做 zag，旋转之后的状态叫做 zagged

LL – 右旋转（单旋）

有些教程里面，把右旋转叫做zig，旋转之后的状态叫做zigged

操作步骤

  • g.left = p.right
  • p.right = g
  • 让 p 成为这颗子树的根节点
  • 旋转后仍然是一颗 二叉搜索树：T0 < n < T1 < p < T2 < g < T3
  • 整棵树都达到平衡

Untitled

  • 还需要注意维护的内容
    • T2、p、g 的 parent 属性
  • 先后更新 g、p 的高度
/**
 * 右旋
 *
 * @param grand
 */
private void rotateRight(Node<E> grand) {
    Node<E> parent = grand.left;
    Node<E> child = parent.right;
    grand.left = child;
    parent.right = grand;
    afterRotate(grand, parent, child);
}

RR – 左旋转（单旋）

有些教程里面，把左旋转叫做zag，旋转之后的状态叫做zagged

操作步骤

  • g.right = p.left
  • p.left = g
  • 让 p 成为这颗子树的根节点
  • 旋转后仍然是一颗 二叉搜索树：T0 < g < T1 < o < T2 < n < T3
  • 整棵树都达到平衡

Untitled

  • 还需要注意维护的内容
    • T1、p、g 的 parent 属性
  • 先后更新 g、p 的高度
/**
 * 左旋
 *
 * @param grand
 */
private void rotateLeft(Node<E> grand) {
    Node<E> parent = grand.right;
    Node<E> child = parent.left;
    grand.right = child;
    parent.left = grand;
    afterRotate(grand, parent, child);
}

LR – 先左旋，再右旋（双旋）

LR 就是 先进行 左旋转 – RR、再进行 右旋转 – LL

  • 先左旋转：p.right = n.left、n.left = p
  • 再右旋转：g.left = n.right、n.right = g
  • 旋转后仍然是一颗 二叉搜索树：T0 < p < T1 < n < T2 < g < T3
  • 整棵树都达到平衡

Untitled

RL – 先右旋，再左旋（双旋）

RL 就是 先进行 右旋转 – LL、再进行 左旋转 – RR

  • 先右旋转：p.left = n.right、n.right = p
  • 再左旋转：g.right = n.left、n.left = g
  • 旋转后仍然是一颗 二叉搜索树：T0 < g < T1 < n < T2 < p < T3
  • 整棵树都达到平衡

Untitled

旋转之后维护的内容

private void afterRotate(Node<E> grand, Node<E> parent, Node<E> child) {
    //让parent成为子树的根节点
    parent.parent = grand.parent;
    if (grand.isLeftChild()) {
        grand.parent.left = parent;
    } else if (grand.isRightChild()) {
        grand.parent.right = parent;
    } else { //grand是根节点
        root = parent;
    }

    //更新child的parent
    if (child != null) {
        child.parent = grand;
    }

    //更新grand的parent
    grand.parent = parent;

    //更新高度
    updateHeight(grand);
    updateHeight(parent);
}

添加之后的修复图解

  • 输入数据：13, 14, 15, 12, 11, 17, 16, 8, 9, 1
  • 输入13：正常
  • 输入14：正常
  • 输入15：13失衡，RR，左旋转

Untitled

  • 输入12：正常
  • 输入11：13失衡，LL，右旋转

Untitled

  • 输入17：正常
  • 输入16：15失衡，RL，先对17进行右旋转、再对15进行左旋转

Untitled

  • 输入8：正常
  • 输入9：11失衡，LR，先对8进行左旋转、再对11进行右旋转

Untitled

  • 输入1：12失衡，LL，对12进行右旋转

Untitled

添加之后的修复 - 代码实现

@Override
protected void afterAdd(Node<E> node) {
    while ((node = node.parent) != null) {
        if (isBalanced(node)) {
            //更新高度
            updateHeight(node);
        } else {
            //恢复平衡
            rebalance(node);
            //整棵树恢复平衡
            break;
        }
    }
}

/**
 * 恢复平衡
 *
 * @param grand 高度最低的那个不平衡节点
 */
private void rebalance(Node<E> grand) {
    Node<E> parent = ((AVLNode<E>) grand).tallerChild();
    Node<E> node = ((AVLNode<E>) parent).tallerChild();
    if (parent.isLeftChild()) { //L
        if (node.isLeftChild()) { //LL
            rotateRight(grand); //右旋
        } else { //LR
            rotateLeft(parent); //左旋
            rotateRight(grand); //右旋
        }
    } else { //R
        if (node.isLeftChild()) { //RL
            rotateRight(parent); //右旋
            rotateLeft(grand); //左旋
        } else { //RR
            rotateLeft(grand); //左旋
        }
    }
}

统一所有的旋转操作

Untitled

private void rotate(
        Node<E> r, //子树的根节点
        Node<E> a, Node<E> b, Node<E> c,
        Node<E> d,
        Node<E> e, Node<E> f, Node<E> g) {
    //让d成为这棵子树的根节点
    d.parent = r.parent;
    if (r.isLeftChild()) {
        r.parent.left = d;
    } else if (r.isRightChild()) {
        r.parent.right = d;
    } else {
        root = d;
    }

    // a - b - c
    b.left = a;
    if (a != null) {
        a.parent = b;
    }
    b.right = c;
    if (c != null) {
        c.parent = b;
    }
    updateHeight(b); //更新b的高度

    // e - f - g
    f.left = e;
    if (e != null) {
        e.parent = f;
    }
    f.right = g;
    if (g != null) {
        g.parent = f;
    }
    updateHeight(f); //更新f的高度

    // b - d - f
    d.left = b;
    d.right = f;
    b.parent = d;
    f.parent = d;
    updateHeight(d); //更新d的高度
}

/**
 * 统一旋转操作
 * 恢复平衡
 *
 * @param grand 高度最低的那个不平衡节点
 */
private void rebalance(Node<E> grand) {
    Node<E> parent = ((AVLNode<E>) grand).tallerChild();
    Node<E> node = ((AVLNode<E>) parent).tallerChild();
    if (parent.isLeftChild()) { //L
        if (node.isLeftChild()) { //LL
            rotate(grand, node.left, node, node.right, parent, parent.right, grand, grand.right);
        } else { //LR
            rotate(grand, parent.left, parent, node.left, node, node.right, grand, grand.right);
        }
    } else { //R
        if (node.isLeftChild()) { //RL
            rotate(grand, grand.left, grand, node.left, node, node.right, parent, parent.right);
        } else { //RR
            rotate(grand, grand.left, grand, parent.left, parent, node.left, node, node.right);
        }
    }
}

删除节点导致的失衡

  • 示例：删除下面这棵子树中的 16
  • 可能会导致父节点或祖先节点失衡（只有1个节点会失衡）
  • 其他节点，都不可能失衡

Untitled

Untitled

LL – 右旋转（单旋）

  • 如果绿色节点不存在，更高层的祖先节点可能也会失衡，需要再次恢复平衡，然后又可能导致更高层的祖先节点失衡…
  • 极端情况下，所有祖先节点都需要进行恢复平衡的操作，共 O(logn) 次调整

Untitled

RR – 左旋转（单旋）

Untitled

LR – RR左旋转，LL右旋转（双旋）

Untitled

RL – LL右旋转，RR左旋转（双旋）

Untitled

删除之后的修复

@Override
protected void afterRemove(Node<E> node) {
    while ((node = node.parent) != null) {
        if (isBalanced(node)) {
            //更新高度
            updateHeight(node);
        } else {
            //恢复平衡
            rebalance(node);
        }
    }
}

AVL树总结

  • 添加
    • 可能会导致所有祖先节点都失衡
    • 只要让高度最低的失衡节点恢复平衡，整棵树就恢复平衡【仅需 O(1) 次调整】
  • 删除
    • 可能会导致父节点或祖先节点失衡（只有1个节点会失衡）
  • 恢复平衡后，可能会导致更高层的祖先节点失衡【最多需要 O(logn) 次调整】
  • 平均时间复杂度
    • 搜索：O(logn)
    • 添加：O(logn)，仅需 O(1) 次的旋转操作
    • 删除：O(logn)，最多需要 O(logn) 次的旋转操作

AVL树完整源码

package cn.xx.java.tree;

import java.util.Comparator;

/**
 * AVL树
 *
 * @author xiexu
 * @create 2021-08-03 10:49 上午
 */
public class AVLTree<E> extends BST<E> {
    public AVLTree() {
        this(null);
    }

    public AVLTree(Comparator<E> comparator) {
        super(comparator);
    }

    /**
     * 添加节点之后的操作
     *
     * @param node 新添加的节点
     */
    @Override
    protected void afterAdd(Node<E> node) {
        while ((node = node.parent) != null) {
            if (isBalanced(node)) { //当前节点是平衡的
                //更新高度
                updateHeight(node);
            } else {
                /**
                 * 恢复平衡
                 * 进去里面的node就是高度最低的那个不平衡节点
                 */
                rebalance(node);
                //整棵树恢复平衡
                break;
            }
        }
    }

    /**
     * 删除节点之后的操作
     *
     * @param node 被删除的节点
     */
    @Override
    protected void afterRemove(Node<E> node) {
        while ((node = node.parent) != null) {
            if (isBalanced(node)) {
                //更新高度
                updateHeight(node);
            } else {
                //恢复平衡
                rebalance(node);
            }
        }
    }

    /**
     * 重写父类中的 createNode
     *
     * @param element
     * @param parent
     * @return
     */
    @Override
    protected Node<E> createNode(E element, Node<E> parent) {
        return new AVLNode<>(element, parent);
    }

    /**
     * 恢复平衡
     *
     * @param grand 高度最低的那个不平衡节点
     */
    private void rebalance2(Node<E> grand) {
        Node<E> parent = ((AVLNode<E>) grand).tallerChild();
        Node<E> node = ((AVLNode<E>) parent).tallerChild();
        if (parent.isLeftChild()) { //L
            if (node.isLeftChild()) { //LL
                rotateRight(grand); //右旋
            } else { //LR
                rotateLeft(parent); //左旋
                rotateRight(grand); //右旋
            }
        } else { //R
            if (node.isLeftChild()) { //RL
                rotateRight(parent); //右旋
                rotateLeft(grand); //左旋
            } else { //RR
                rotateLeft(grand); //左旋
            }
        }
    }

    /**
     * 统一旋转操作
     * 恢复平衡
     *
     * @param grand 高度最低的那个不平衡节点
     */
    private void rebalance(Node<E> grand) {
        Node<E> parent = ((AVLNode<E>) grand).tallerChild();
        Node<E> node = ((AVLNode<E>) parent).tallerChild();
        if (parent.isLeftChild()) { //L
            if (node.isLeftChild()) { //LL
                rotate(grand, node.left, node, node.right, parent, parent.right, grand, grand.right);
            } else { //LR
                rotate(grand, parent.left, parent, node.left, node, node.right, grand, grand.right);
            }
        } else { //R
            if (node.isLeftChild()) { //RL
                rotate(grand, grand.left, grand, node.left, node, node.right, parent, parent.right);
            } else { //RR
                rotate(grand, grand.left, grand, parent.left, parent, node.left, node, node.right);
            }
        }
    }

    private void rotate(
            Node<E> r, //子树的根节点
            Node<E> a, Node<E> b, Node<E> c,
            Node<E> d,
            Node<E> e, Node<E> f, Node<E> g) {
        //让d成为这棵子树的根节点
        d.parent = r.parent;
        if (r.isLeftChild()) { // r是父节点的左子节点
            r.parent.left = d;
        } else if (r.isRightChild()) { // r是父节点的右子节点
            r.parent.right = d;
        } else { // r是根节点
            root = d;
        }

        // a - b - c
        b.left = a;
        if (a != null) {
            a.parent = b;
        }
        b.right = c;
        if (c != null) {
            c.parent = b;
        }
        updateHeight(b); //更新b的高度

        // e - f - g
        f.left = e;
        if (e != null) {
            e.parent = f;
        }
        f.right = g;
        if (g != null) {
            g.parent = f;
        }
        updateHeight(f); //更新f的高度

        // b - d - f
        d.left = b;
        d.right = f;
        b.parent = d;
        f.parent = d;
        updateHeight(d); //更新d的高度
    }

    /**
     * 左旋
     *
     * @param grand
     */
    private void rotateLeft(Node<E> grand) {
        Node<E> parent = grand.right;
        Node<E> child = parent.left;
        grand.right = child;
        parent.left = grand;
        afterRotate(grand, parent, child);
    }

    /**
     * 右旋
     *
     * @param grand
     */
    private void rotateRight(Node<E> grand) {
        Node<E> parent = grand.left;
        Node<E> child = parent.right;
        grand.left = child;
        parent.right = grand;
        afterRotate(grand, parent, child);
    }

    /**
     * 公共代码：不管是左旋转、右旋转，都要执行
     *
     * @param grand  失衡节点
     * @param parent
     * @param child
     */
    private void afterRotate(Node<E> grand, Node<E> parent, Node<E> child) {
        //让parent成为子树的根节点
        parent.parent = grand.parent;
        if (grand.isLeftChild()) {
            grand.parent.left = parent;
        } else if (grand.isRightChild()) {
            grand.parent.right = parent;
        } else { //grand是根节点
            root = parent;
        }

        //更新child的parent
        if (child != null) {
            child.parent = grand;
        }

        //更新grand的parent
        grand.parent = parent;

        //更新高度
        updateHeight(grand);
        updateHeight(parent);
    }

    /**
     * 判断传入节点是否平衡
     *
     * @param node
     * @return
     */
    private boolean isBalanced(Node<E> node) {
        return Math.abs(((AVLNode<E>) node).balanceFactor()) <= 1;
    }

    /**
     * 更新高度
     *
     * @param node
     */
    private void updateHeight(Node<E> node) {
        ((AVLNode<E>) node).updateHeight();
    }

    /**
     * AVL树节点
     *
     * @param <E>
     */
    private static class AVLNode<E> extends Node<E> {

        int height = 1; //叶子节点的默认高度就是1

        public AVLNode(E element, Node<E> parent) {
            super(element, parent);
        }

        /**
         * 返回当前节点的平衡因子
         *
         * @return
         */
        public int balanceFactor() {
            int leftHeight = left == null ? 0 : ((AVLNode<E>) left).height;
            int rightHeight = right == null ? 0 : ((AVLNode<E>) right).height;
            return leftHeight - rightHeight;
        }

        /**
         * 更新节点的高度
         */
        public void updateHeight() {
            int leftHeight = left == null ? 0 : ((AVLNode<E>) left).height;
            int rightHeight = right == null ? 0 : ((AVLNode<E>) right).height;
            height = 1 + Math.max(leftHeight, rightHeight);
        }

        /**
         * 返回高度较高的那个子节点
         * 因为p总是左右子树中高度最高的那个节点
         * n也总是左右子树中高度最高的那个节点
         *
         * @return
         */
        public Node<E> tallerChild() {
            int leftHeight = left == null ? 0 : ((AVLNode<E>) left).height;
            int rightHeight = right == null ? 0 : ((AVLNode<E>) right).height;
            if (leftHeight > rightHeight) {
                return left;
            }
            if (leftHeight < rightHeight) {
                return right;
            }
            /**
             * 左右高度相同，就返回与父节点的子节点同方向的那个节点
             */
            return isLeftChild() ? left : right;
        }

        @Override
        public String toString() {
            String parentString = "null";
            if (parent != null) {
                parentString = parent.element.toString();
            }
            return element + "_p(" + parentString + ")_h(" + height + ")";
        }
    }
}

练习

110_平衡二叉树

Untitled

package 二叉树;

/**
 * https://leetcode-cn.com/problems/balanced-binary-tree/
 *
 * @author xiexu
 * @create 2021-08-04 11:50 上午
 */
public class _110_平衡二叉树 {

    public boolean isBalanced(TreeNode root) {
        return getHeight(root) != -1;
    }

    public int getHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = getHeight(root.left);
        if (leftHeight == -1) {
            return -1;
        }
        int rightHeight = getHeight(root.right);
        if (rightHeight == -1) {
            return -1;
        }
        // 左右子树高度差大于1，return -1表示已经不是平衡树了
        if (Math.abs(leftHeight - rightHeight) > 1) {
            return -1;
        }
        return Math.max(leftHeight, rightHeight) + 1;
    }

}
猿小羽
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
平衡二叉树和AVL
qq_48019875的博客
12-16 1350
目录一、AVL二、平衡二叉树三、代码实现四、测试五、AVL的左旋转和右旋转（1）维护平衡的时机（2）插入的元素在不平衡节点的左侧的左侧右旋代码实现（3）插入的元素在不平衡节点的右侧的右侧左旋代码实现六、LR和RL1、**插入的元素不在平衡节点的左侧的右侧**2、**插入的元素在不平衡结点的左侧的右侧**代码实现七、AVL树的删除八、测试九、完整代码 平衡二叉树和AVL树是在二分搜索树的基础上进行讲解 回忆二分搜索树的问题： 添加数据 ：是按照顺序添加的 32145 每个节点的左节点小于根节点，每个节点的右
【数据结构】平衡二叉搜索树、AVL树
一个写湿的程序猿
02-02 495
目录二叉搜索树缺点分析改进二叉搜索树平衡（Balance）理想平衡如何改进二叉搜索树？平衡二叉搜索树（Balanced Binary Search Tree）AVL树BST 对比 AVLTree继承 BSTAVL 树基础添加节点导致的失衡LL – 右旋转（单旋） 二叉搜索树缺点分析 当 n 比较大时，两者的性能差异比较大 比如 n = 1000000 时，二叉搜索树的最低高度是 20，最高高度是 1000000； 由此可见，二叉搜索树添加节点时可能会导致二叉搜索树退化成链表； 而删除节点时也可能会导致
二叉搜索树与AVL树
DayDayUp
01-05 883
目录 二叉搜索树 AVL树 AVL树的旋转 LL旋转 LR旋转 RR旋转 RL旋转 二叉搜索树 二叉查找树(Binary Search Tree)，(又:二叉搜索树，二叉排序树)它或者是一棵空树，或者是具有下列性质的二叉树: 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值; 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值; 它的左、右子树也分别为二叉排序树。左小右大：小于根节点的数放左边，大于根节点的数放右边。重复的节点值不允许出现 二叉搜索树中序遍历得到的值.
数据结构-二叉搜索树与AVL树
Coder Liu的博客
07-07 498
二叉搜索树 二叉搜索树属于二叉树,具有如下的性质: 1.节点的左子树不为空,那么左子树所有的节点的值都小于该节点的值 2.节点的右子树不为空,那么右子树所有的节点的值都大于该节点的值. 3.节点的左右子树都是二叉搜索树. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e2zyxSEF-1594085941066)(evernotecid://8BF4008B-52C0-484E-A4B5-8EBD45F20215/appyinxiangcom/13973009/ENResou
二叉搜索树及AVL
ZergWang's Blog
11-30 655
二叉搜索树（Binary Search Tree） 又称二叉排序树，对于此树中的任一节点，其左子树所有节点的值都比该节点小，其右子树所有节点都比该节点大。因此，该树的中序遍历会得到一个有序序列。 平衡二叉搜索树 B树 B+树 红黑树 ...
二叉搜索树（C#，C++）
10-11
为了保持高效性，可以考虑自平衡二叉搜索树，如AVL树或红黑树。这些树通过旋转操作来维持平衡，确保最坏情况下的时间复杂度为O(logn)。 6. **遍历**：二叉搜索树支持中序遍历（左-根-右），可以得到有序序列。这...
binarytree:二叉搜索树
03-05
为解决这个问题，可以使用自平衡二叉搜索树，如AVL树和红黑树，它们通过旋转操作保持树的平衡，确保查找、插入和删除操作的平均时间复杂度为O(log n)。 7. **C语言实现**：在C语言中实现二叉搜索树，需要定义一个...
二叉排序树与平衡二叉树的实现
12-26
二叉平衡树：若不是空树，则(1)左右子树都是平衡二叉树；(2)左右子树的深度之差的绝对值不超过1。 本次实验是利用二叉排序树和平衡二叉树达到以下目的：(1)以回车('\n')为输入结束标志,输入数列L，生成一棵二叉...
第8章-高级搜索树2
08-04
【第8章 高级搜索树2 - 伸展树】 伸展树是一种平衡二叉搜索树，由D. D. Sleator和R. E. Tarjan在1985年提出，它与AVL树相比，实现更为简单。伸展树的核心思想是通过动态调整树的结构来适应数据访问的局部性原则，即...
Java程序设计与数据结构第五章习题答案
11-05
常见的树类型有二叉树、二叉搜索树、平衡树（AVL、红黑树）等。二叉搜索树保证左子树所有节点小于根节点，右子树所有节点大于根节点，便于快速查找。 6. **排序算法**：在处理数据结构时，排序算法也至关重要，例如...
通俗易懂的图解二叉搜索树、AVL树和红黑树
暗色光的博客
07-06 453
搜索是一种很常见的需求，当数据较多时，如何找到目标对象时，即需要搜索查找。 那么如何快速找到目标呢，最朴素的思想就是暴力查找，一个一个对比。 显然，当数据量增大时，我们需要优化查找方法获取更快的查找速度，我们可以通过维护一个有序数组，从而实现二分查找，查找速度从O(n)降为O(longn)。 但是数组并不便于插入和删除，链表便成为了最好的选择。 既然是采用二分查找，那么不如直接按照查找的步骤维护一种数据结构，于是二叉搜索树出现了。 二叉搜索树的性质为： 若左子树不为空，则左子树上所有节点值都小于根结点值；
二叉搜索树和AVL树基本概念
leslie___的博客
05-02 449
什么是二叉搜索树 二叉搜索树也叫二叉排序树或二叉查找树 二叉搜索树，一棵二叉树可以为空也可以不空，如果不为空就满足以下性质： 非空左子树的所有键值小于其根结点的键值 非空右子树的所有键值大于其根结点的键值 左、右子树都是二叉搜索树 二叉搜索树操作的特别函数 Position Find(ElementType X,BinTree BST) /*从二叉搜索树BST中查找元素X，返回其所在结点的...
改进的二叉搜索树-AVL树与伸展树(Splay)
weixin_33957648的博客
07-23 409
平衡的二叉搜索树 (AVL) 性质 可以为空 具有 n 个结点的 AVL 树，高度为 O (log n) 如果 T是一棵 AVL树，那么它的左右子树 TL、TR 也是 AVL 树 并且 | hL-hR|≤1 hL、hR 是它的左右子树的高度 平衡因子 平衡因子，bf (x) : Bf (x) = h(左孩子) - h(右孩子) 结点平衡因子可能取值为 0，1 和 -1 AVL 树结点...
二叉搜索树增删改查完整实现(C++)
zorchp
01-19 1353
-
数据结构与算法 平衡二叉搜索树
lm324114的专栏
08-17 358
平衡二叉搜索树 如果二叉排序树是平衡的，则n个节点的二叉排序树的高度为,其查找效率为，近似于折半查找。 如果二叉排序树完全不平衡，则其深度可达到n，查找效率为O(n)，退化为顺序查找。一般的，二叉排序树的查找性能在到O(n)之间。 因此，为了获得较好的查找性能，就要构造一棵平衡的二叉排序树。 平衡 当节点数量固定时，左右子树的高度越接近，这颗二叉树就越平衡（高度越低） 最理想的平衡，就是像完全二叉树、满二叉树那样，高度是最小的 如何改进二叉树搜索树 首先，节点的添加、删除是...
平衡二叉树
angbao4913的博客
09-16 206
高级树的总结 参考《邓俊辉的数据结构》 AVL(Adelson-Velskii 和Landis)树 AVL(Adelson-Velskii 和Landis)树是带有平衡条件的二叉查找树, 保证树的深度为O(logN); 左右子树具有相同的高度, 高度差最多差1, 用一次或两次旋转操作维持平衡状态; 理想平衡和适度平衡的概念: 二叉搜索树的性能主要取决于高度, 固在节点数目固定的前提...
创建理想的平衡二叉树
flyfish
10-25 5090
创建理想的平衡二叉树 2008年10月25日 理想的平衡二叉树,包括满二叉树和完全二叉树.也就是层次建立二叉树 假设有数字1,2,3,4,5,6,7,8,9要组合成如下图所示的一颗完全二叉树.     1  2     3 4  5  6  78 9节点1的数据域的值是1节点2的数据域的值是2节点3的数据域的值是3依次类推 #include#includeu
BST(二叉搜索树),AVL(平衡二叉树)、RBT(红黑树)的区别
森明帮大于黑虎帮的博客
08-29 6388
文章目录
MySQL索引原理
热门推荐
Dobbin
02-02 3万+
B+树索引是B+树在数据库中的一种实现，是最常见也是数据库中使用最为频繁的一种索引。B+树中的B代表平衡（balance），而不是二叉（binary），因为B+树是从最早的平衡二叉树演化而来的。在讲B+树之前必须先了解二叉查找树、平衡二叉树（AVLTree）和平衡多路查找树（B-Tree），B+树即由这些树逐步优化而来。
第九章集合答案1.doc
最新发布
12-11
7. 旋转操作：如第58题提到的LR型旋转，是保持AVL树平衡的一种常见操作，通过调整节点位置来重新达到平衡条件。 8. 成功查找概率计算：最后，文档提供了两个关于ASLsuss（成功查找平均长度）的计算实例，分别计算了...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

猿小羽

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

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

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

打赏作者

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

抵扣说明：

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

余额充值