Java数据结构与算法解析(六)——AVL树

最新推荐文章于 2024-03-13 17:02:47 发布
最新推荐文章于 2024-03-13 17:02:47 发布
阅读量1.7w 收藏 71
点赞数 14
分类专栏： 数据结构与算法 文章标签： AVL树 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012124438/article/details/78026414
版权

之前我们说过普通二叉查找树的删除算法会使得左子树比右子树深，因为我们总是用右子树的一个来代替删除的节点。会造成二叉查找树，严重的不平衡。

AVL树简介

而AVL树就是解决普通二叉查找树弊端的方法，他是带有平衡条件的二叉查找树，这个平衡条件必须容易保持，而且它保证树的深度必须是O(logN).

AVL树是高度平衡的而二叉树。它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。

这里写图片描述

上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。

AVL树的实现

1.节点

// 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;
        }
    }

AVLTree是AVL树对应的类，而AVLTreeNode是AVL树节点，它是AVLTree的内部类。AVLTree包含了AVL树的根节点，AVL树的基本操作也定义在AVL树中。AVLTreeNode包括的几个组成对象:
(1) key – 是关键字，是用来对AVL树的节点进行排序的。
(2) left – 是左孩子。
(3) right – 是右孩子。
(4) height – 是高度。

2.树的高度

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

    return 0;
}

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

有的地方将”空二叉树的高度是-1”，这里我们采用另一种定义：树的高度为最大层次。即空的二叉树的高度是0，非空树的高度等于它的最大层次(根的层次为1，根的子节点为第2层，依次类推)。

3.旋转

如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。这种失去平衡的可以概括为4种姿态：LL(左左)，LR(左右)，RR(右右)和RL(右左)。

这里写图片描述

上图中的4棵树都是”失去平衡的AVL树”，从左往右的情况依次是：LL、LR、RL、RR。除了上面的情况之外，还有其它的失去平衡的AVL树，如下图：
这里写图片描述

(1) LL：LeftLeft，也称为”左左”。插入或删除一个节点后，根节点的左子树的左子树还有非空子节点，导致”根的左子树的高度”比”根的右子树的高度”大2，导致AVL树失去了平衡。
例如，在上面LL情况中，由于”根节点(8)的左子树(4)的左子树(2)还有非空子节点”，而”根节点(8)的右子树(12)没有子节点”；导致”根节点(8)的左子树(4)高度”比”根节点(8)的右子树(12)”高2。

(2) LR：LeftRight，也称为”左右”。插入或删除一个节点后，根节点的左子树的右子树还有非空子节点，导致”根的左子树的高度”比”根的右子树的高度”大2，导致AVL树失去了平衡。
例如，在上面LR情况中，由于”根节点(8)的左子树(4)的左子树(6)还有非空子节点”，而”根节点(8)的右子树(12)没有子节点”；导致”根节点(8)的左子树(4)高度”比”根节点(8)的右子树(12)”高2。

(3) RL：RightLeft，称为”右左”。插入或删除一个节点后，根节点的右子树的左子树还有非空子节点，导致”根的右子树的高度”比”根的左子树的高度”大2，导致AVL树失去了平衡。
例如，在上面RL情况中，由于”根节点(8)的右子树(12)的左子树(10)还有非空子节点”，而”根节点(8)的左子树(4)没有子节点”；导致”根节点(8)的右子树(12)高度”比”根节点(8)的左子树(4)”高2。

(4) RR：RightRight，称为”右右”。插入或删除一个节点后，根节点的右子树的右子树还有非空子节点，导致”根的右子树的高度”比”根的左子树的高度”大2，导致AVL树失去了平衡。
例如，在上面RR情况中，由于”根节点(8)的右子树(12)的右子树(14)还有非空子节点”，而”根节点(8)的左子树(4)没有子节点”；导致”根节点(8)的右子树(12)高度”比”根节点(8)的左子树(4)”高2。

如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。AVL失去平衡之后，可以通过旋转使其恢复平衡，下面分别介绍”LL(左左)，LR(左右)，RR(右右)和RL(右左)”这4种情况对应的旋转方法。

LL的旋转
LL失去平衡的情况，可以通过一次旋转让AVL树恢复平衡。如下图：
这里写图片描述

图中左边是旋转之前的树，右边是旋转之后的树。从中可以发现，旋转之后的树又变成了AVL树，而且该旋转只需要一次即可完成。
对于LL旋转，你可以这样理解为：LL旋转是围绕”失去平衡的AVL根节点”进行的，也就是节点k2；而且由于是LL情况，即左左情况，就用手抓着”左孩子，即k1”使劲摇。将k1变成根节点，k2变成k1的右子树，”k1的右子树”变成”k2的左子树”。

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;
    }

RR的旋转
理解了LL之后，RR就相当容易理解了。RR是与LL对称的情况！RR恢复平衡的旋转方法如下：
这里写图片描述

图中左边是旋转之前的树，右边是旋转之后的树。RR旋转也只需要一次即可完成。

 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的旋转
LR失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。
这里写图片描述

第一次旋转是围绕”k1”进行的”RR旋转”，第二次是围绕”k3”进行的”LL旋转”。

LR的旋转代码

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

        return leftLeftRotation(k3);
    }

RL的旋转
RL是与LR的对称情况！RL恢复平衡的旋转方法如下：
这里写图片描述

第一次旋转是围绕”k3”进行的”LL旋转”，第二次是围绕”k1”进行的”RR旋转”。

RL的旋转代码

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

        return rightRightRotation(k1);
    }

4.插入

 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);
    }

插入节点后，可能会使AVL树失去平衡，通过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;
    }

5.删除

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;

    }

删除操作就是在原来查找二叉树的基础上，每一次删除都调用balance()方法对AVL树进行再平衡。

完整的实现代码如下：

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);
    }
}

AVL树的测试程序

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("\n== 前序遍历: ");
        tree.preOrder();

        System.out.printf("\n== 中序遍历: ");
        tree.inOrder();

        System.out.printf("\n== 后序遍历: ");
        tree.postOrder();
        System.out.printf("\n");

        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== 中序遍历: ");
        tree.inOrder();
        System.out.printf("\n== 树的详细信息: \n");
        tree.print();
    }
}

AVL树测试程序流程进行分析

  1. 新建AVL树

  2. 依次添加”3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9” 到AVL树中。
    2.01 添加3,2
    添加3,2都不会破坏AVL树的平衡性。
    这里写图片描述
    2.02 添加1
    添加1之后，AVL树失去平衡(LL)，此时需要对AVL树进行旋转(LL旋转)。旋转过程如下：
    这里写图片描述
    2.03 添加4
    添加4不会破坏AVL树的平衡性。
    这里写图片描述
    2.04 添加5
    添加5之后，AVL树失去平衡(RR)，此时需要对AVL树进行旋转(RR旋转)。旋转过程如下：
    这里写图片描述
    2.05 添加6
    添加6之后，AVL树失去平衡(RR)，此时需要对AVL树进行旋转(RR旋转)。旋转过程如下：
    这里写图片描述
    2.06 添加7
    添加7之后，AVL树失去平衡(RR)，此时需要对AVL树进行旋转(RR旋转)。旋转过程如下：
    这里写图片描述
    2.07 添加16
    添加16不会破坏AVL树的平衡性。
    这里写图片描述
    2.08 添加15
    添加15之后，AVL树失去平衡(RR)，此时需要对AVL树进行旋转(RR旋转)。旋转过程如下：
    这里写图片描述
    2.09 添加14
    添加14之后，AVL树失去平衡(RL)，此时需要对AVL树进行旋转(RL旋转)。旋转过程如下：
    这里写图片描述
    2.10 添加13
    添加13之后，AVL树失去平衡(RR)，此时需要对AVL树进行旋转(RR旋转)。旋转过程如下：
    这里写图片描述
    2.11 添加12
    添加12之后，AVL树失去平衡(LL)，此时需要对AVL树进行旋转(LL旋转)。旋转过程如下：
    这里写图片描述
    2.12 添加11
    添加11之后，AVL树失去平衡(LL)，此时需要对AVL树进行旋转(LL旋转)。旋转过程如下：
    这里写图片描述
    2.13 添加10
    添加10之后，AVL树失去平衡(LL)，此时需要对AVL树进行旋转(LL旋转)。旋转过程如下：
    这里写图片描述
    2.14 添加8
    添加8不会破坏AVL树的平衡性。
    这里写图片描述
    2.15 添加9
    但是添加9之后，AVL树失去平衡(LR)，此时需要对AVL树进行旋转(LR旋转)。旋转过程如下：
    这里写图片描述

进击的代码家
关注
  • 14
    点赞
  • 踩
  • 71
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
基于java语言手动实现的AVL树代码
11-09
基于java语言手动实现的AVL树代码，该树形结构适用于查找，实现的逻辑可以查看博主的原创作品《用JAVA代码手动实现AVL树》
每日算法总结——有序表系列——详解 AVL 树（Java）
qq_53661372的博客
04-15 106
所谓 LL 型就是上图左边那种情况，即因为在根节点的左孩子的左子树添加了新节点，导致树的高度差变为 +2，二叉树失去平衡。为了保证二叉树的平衡， AVL 树引入了所谓监督机制，就是在树的某一部分的不平衡度超过一个阈值后触发相应的平衡操作。LR 就是将新的节点插入到了 n 的左孩子的右子树上导致的不平衡的情况。RL 就是将新的节点插入到了 n 的右孩子的左子树上导致的不平衡的情况。也很简单，我们可以根据破坏树的平衡性（子树高度差的绝对值大于 1）的节点以及其子节点的平衡因子来判断平衡化类型。
神经网络中激活函数的绘制——阶跃函数、sigmoid函数、ReLU函数
最新发布
m0_67587248的博客
03-13 668
【代码】神经网络中激活函数的绘制——阶跃函数、sigmoid函数、ReLU函数。
【Java】高级数据结构算法 -- AVL树
阿坤~的博客
07-07 370
目录 1.概念 AVL树的定义： AVL树性质： AVL树效率： 2.AVL树基本类型定义代码 3.插入 AVL四种旋转操作 插入代码实现 4.删除 5.判断一棵二叉搜索树树是否是AVL树 6.测试代码 7.1~10十个数的AVL数的插入图解 ...
Java实现AVL树的判定问题（改编版）
qq_52434831的博客
11-14 241
Java实现AVL树的判定问题
二叉树之AVL树及其Java实现
liyangxueit的博客
08-26 299
AVL树平衡的定义 下图中，之所以右图的二叉树不是AVL树，是因为在节点7处，其左子树高度为2，右子树高度却为0，所以不平衡。 AVL树不平衡场景 总共不平衡由以下几种情景造成： 边界情景一：研究节点的左儿子的左子树破坏了平衡——>左子树单旋转 ...
数据结构与算法AVL树类的C++实现
01-20
关于AVL树的简介可以参考： 数据结构与算法——AVL树简介 　关于二叉搜索树（也称为二叉查找树）可以参考：数据结构与算法——二叉查找树类的C++实现 　AVL-tree是一个加上了额外平衡条件的二叉搜索树，其平衡条件...
数据结构与算法的一些实例，数据结构包括图（遍历算法）、树（哈夫曼树、AVL平衡树等）
01-15
数据结构与算法的一些实例，数据结构包括图（遍历算法）、树（哈夫曼树、AVL平衡树等），算法包括查找算法（二分查找、斐波那契查找等）、排序算法（快速排序、堆排序等）、贪心算法、KMP算法等.zip
java数据结构与算法之平衡二叉树AVL树的设计与实现分析.doc
11-17
java数据结构与算法之平衡二叉树AVL树的设计与实现分析.doc
java数据结构算法简介.txt
07-16
相当好的一份数据结构与算法资源课（偏算法），但记住这个是java的。 算法包括归并、快速排序、二分查找法、希尔排序、冒泡排序、非比较排序等等。 数据结构有红黑树、AVL树，挺多，但是好像需要对树有一定的基础...
JAVA数据结构和算法（内含视频和代码）
04-18
第1章 欢迎学习《玩转数据结构》 第2章 不要小瞧数组 第3章 栈和队列 第4章 最基础的动态数据结构：链表 第5章 链表和递归 第6章 二分搜索树 第7章 集合和映射 第8章 优先队列和堆 第9章 线段树 第10章 Trie 第11章 ...
【Java数据结构】BST树(二叉搜索树)总结05（判断二叉树是否是BST树，AVL树）
懂技术的猫
07-07 585
二叉树总结：入口 二叉树的基本操作： 1、插入，删除 操作 2、前、中、后序遍历，层序遍历 3、求BST树高度，求BST树节点个数 4、返回中序遍历第k个节点的值 5、判断一个二叉树是否是BST树，判断一个BST树是否是AVl树 6、BST树的镜像 7、把BST树满足[begin，end]区间的值放在集合中、打印出来 8、判断是否是子树 9、按层打印二叉树 1、判断是否...
【数据结构】初入数据结构中的平衡二叉搜索树(AVL树)及Java实现
长路漫漫的歇脚处
07-09 994
初入数据结构中的平衡二叉搜索树（AVL树）
判断一颗二叉树是否为AVL树(Java)
weixin_45408048的博客
09-10 599
如果左子树是AVL树,右子树是AVL树,他们的高度差小于等于1,那就是AVL树;否则不是. public class IsAVLTree { public static boolean isAVL(TreeNode root) { if (root==null) { return true; } int diff=Math.abs(getHeigt(root.lchild)-getHeigt(root.rchild)); if (isAVL(root.lchild)&&amp
Java手写AVL树（非常详细）
fengxiandada的博客
04-08 2397
文章目录1. 二叉搜索树复杂度2. BST的平衡3. 改进二叉搜索树4. 平衡二叉搜索树（Balanced Binary Search Tree）5. AVL树5.1 AVL树的相关概念及特点5.2 普通BST和AVL树添加对比6. AVL树设计6.1 继承结构6.2 普通BST添加导致失衡例子6.3 解决添加失衡——LL-右旋转(单旋)6.4 解决添加失衡——RR-左旋转(单旋)6.5 解决添加失衡——LR-RR左旋转，LL右旋转(双旋)6.6 解决添加失衡——RL-LL右旋转，RR左旋转(双旋)6.7
【数据结构与算法】AVL树（1）——简介
葑鈊丶
10-31 1548
文章目录AVL树的来源AVL树的定义AVL树的高度最小结点数最大结点数相关文章 AVL树的来源   AVL树得名于它的发明者G. M. Adelson-Velsky和Evgenii Landis。在计算机科学中，AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。 AVL树的定义 ·它是一棵二叉搜索树； ·对任意结点X，X左右子树...
数据结构——AVL树
stromSLR的博客
02-27 1284
AVL算法 前言 这篇文章主要是基于BST算法的衍生版本，因为在某些情况下，BST算法的时间复杂度会退化成O(n),所以才有了这个完全平衡的AVL算法，会通过平衡因子维护二叉搜索树的平衡，保证其查找时的时间复杂度为O(log2(n))，但是也有缺陷。 一、AVL算法的性质 1.左右子树高度差（平衡因子）的绝对值不超过1 （1）高度差——平衡因子 每个节点都有自己的平衡因子，当平衡因子大于1时，我们就需要进行调整，使其小于等于1 （2） 这里，一般我们默认平衡因子的大小是右树减左树 例如：右数高度为2，左树高
树（三）AVL树
kdb_viewer的博客
09-19 859
AVL树是对二叉查找树的改进，注意任何对二叉查找树的改进都必须保证树具有O(logN)的深度或摊还深度，若深度增加到O(N)级别，就和链表一样了，没有意义。AVL树保证了O(logN)深度的同时具有平衡性，是一种自平衡二叉查找树。AVL树平均高度大概是1.44logN + c，c是常数，是O(logN)级别。 比二叉查找树增加的结构性：要求每个节点的左子树和右子树的高度相差最多为1,（为了方便N...
Java实现AVL树（自平衡二叉搜索树）
m0_60936579的博客
10-12 911
一、AVL树的概念 AVL树本质上是一棵二叉搜索树，即它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树。另外，AVL树每个结点的左右子树的高度之差，即平衡因子的绝对值不超过1，以实现查询操作的时间复杂度从传统二叉搜索树的O(N)降为O(logN)。 二、平衡调整 首先，为什么AVL树需要有“自平衡”的功能？其实从A...
Java算法与数据结构测试——二叉树
04-06
二叉树是一种树形结构，其中每个节点最多有两个子节点。一个节点的左子节点比该节点小，右子节点比该节点大。二叉树通常用于搜索和排序。 2. 二叉树的遍历方法有哪些？ 二叉树的遍历方法包括前序遍历、中序遍历和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

进击的代码家

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

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

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

打赏作者

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

抵扣说明：

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

余额充值