自已着手作图搞清楚AVL树

admin 3周前 (07-23) 科技 16 0

@

目录
  • 一、靠山
  • 二、平衡二分搜索树---AVL树
    • 2.1 AVL树的基本概念
      • 结点
      • 高度
      • 平衡因子
    • 2.2 AVL树的验证
  • 三、旋转操作
    • 3.1 L L--需要通过右旋操作
    • 3.2 R R--需要通过左旋操作
    • 3.3 L R--需要先通过左旋再右旋操作
    • 2.4 R L--需要先通过右旋再左旋操作
  • 四、AVL树完整代码实现

一、靠山

二叉树是一种常用的数据结构,更是实现众多算法的一把利器。(可参考《自己着手作图深入明白二叉树、满二叉树及完全二叉树》)
二分搜索树(Binary Search Tree)做为一种能实现快速定位查找的二叉树也得到了广泛应用(底层实现可参考《用一个图书库实例搞懂二分搜索树的底层原理》)。

1 二分搜索树是一颗二叉树
2 二分搜索树每个节点的左子树的值都小于该节点的值,每个节点右子树的值都大于该节点的值
3 随便一个节点的每棵子树都知足二分搜索树的界说

  • 但二分搜索树也有其局限性:好比我们给定[1,2,3,4,5,6,7]这样的数据并按顺序组成的二分搜索树就褪化成了线性链表,二分搜索树极端偏向右侧,且深度到达7级,查找搜索的时间复杂度也从O(logn)褪化成了O(n).

二、平衡二分搜索树---AVL树

  • 为了解决二分搜索树的不平衡性,科学家缔造一种自平衡的二分搜索树,这种树也被简称为AVL(G. M. Adelson-Velsky和E. M. Landis)树,以下的图即为一棵AVL树:
2.1 AVL树的基本概念

每个结点的左右子树的高度之差(平衡因子)不大于1的二分搜索树,即为AVL树。

结点
  • 结点是组成二叉树的最小单元。
    -- 用图形示意
    自已着手作图搞清楚AVL树 第1张
    -- 用代码示意
	// 结点
	class Node<E> {
        E e;
        Node left, right;

        Node(E e) {
            this.e= e;
            this.left = null;
            this.right = null;
        }
    }
高度
  • 叶子结点高度默以为1;非叶子结点的高度为该结点能到达的左子树或右子树的叶子结点的最大跨度。
    自已着手作图搞清楚AVL树 第2张

-- 用代码形貌

	class Node<E> {
        E e;
        Node left, right;
        // 高度
        int height;

        Node(E e) {
            this.e = e;
            this.left = null;
            this.right = null;
            // 叶子结点高度默以为1
            this.height = 1;
        }
    }
	// 获得节点node的高度
    private int getHeight(Node node) {
        if (node == null) {
            return 0;
        }
        return node.height;
    }
	// 盘算结点的高度
    private void setHeight(Node node) {
        node.height = Math.max(getHeight(node.left), getHeight(node.right)) + 1;
    }
平衡因子
  • 叶子结点的平衡因子为0;非叶子结点的平衡因子为该结点的左子结点或右子结点的高度差。
    自已着手作图搞清楚AVL树 第3张

-- 用代码形貌

	class Node<E> {
        E e;
        Node left, right;
        // 高度
        int height;

        Node(E e) {
            this.e = e;
            this.left = null;
            this.right = null;
            // 叶子结点高度默以为1
            this.height = 1;
        }
    }
	// 获得节点node的高度
    private int getHeight(Node node) {
        if (node == null) {
            return 0;
        }
        return node.height;
    }

	// 获得节点node的平衡因子
    private int getBalanceFactor(Node node){
        if(node == null)
            return 0;
        return getHeight(node.left) - getHeight(node.right);
    }
2.2 AVL树的验证

自已着手作图搞清楚AVL树 第4张

  • 按AVL的界说,判断一棵二叉树是否为AVL树
    • 首先需判断这棵二叉树是否为二分搜索树:即从根结点最先中序遍历该二叉树,形成的遍历序列一定是按从小到大有序排列的
    • 实在判断该二分搜索树的每个结点的平衡因子的绝对值是否跨越1

-- 用代码形貌

/**
 * AVL树
 * @param <E> 泛型元素
 * @author zhuhuix
 * @date 2020-07-21
 */
public class AVL<E extends Comparable<E>> {

    // 私有内部类-树结点
    private class Node<E> {
        E e;
        Node left, right;
        // 高度
        int height;

        Node(E e) {
            this.e = e;
            this.left = null;
            this.right = null;
            this.height = 1;
        }

    }

    // 根结点
    private Node root;

    // 获得节点node的高度
    private int getHeight(Node node) {
        if (node == null) {
            return 0;
        }
        return node.height;
    }

    // 盘算结点的高度
    private int setHeight(Node node) {
        return node.height = Math.max(getHeight(node.left), getHeight(node.right)) + 1;
    }

    // 获得节点node的平衡因子
    private int getBalanceFactor(Node node) {
        if (node == null) {
            return 0;
        }
        return getHeight(node.left) - getHeight(node.right);
    }

    // 增添元素
    public void add(E e) {
        root = addNode(root, e);
    }

    // 通过递归算法遍历现有结点,将新结点插入到合适的位置
    private Node addNode(Node node, E element) {

        if (node == null) {
            System.out.println("新增元素[" + element + "] height=1");
            return new Node(element);
        }

        // 新加入元素小于结点值,往左子树增添
        if (element.compareTo((E) node.e) < 0) {
            node.left = addNode(node.left, element);
            // 新加入元素大于结点值,往右子树增添
        } else if (element.compareTo((E) node.e) > 0) {
            node.right = addNode(node.right, element);
        } else // element.compareTo(node.e) == 0
        {
            node.e = element;
        }
        // 更新height
        node.height = setHeight(node);
        System.out.println("元素[" + node.e + "] 更新高度: height=" + node.height);
        return node;
    }

    // 判断二叉树是否为二分搜索树:从根结点中序遍历形成的序列是否从小到大有序排列
    public boolean isBST() {
        ArrayList<E> arrayList = new ArrayList<>();
        InOrderTraversal(root, arrayList);
        for (int i = 0; i < arrayList.size() - 1; i++) {
            // 相邻两个元素对照,若是前一个元素大于后一个元素,则不为二分搜索树
            if (arrayList.get(i).compareTo(arrayList.get(i + 1)) > 0) {
                return false;
            }
        }
        System.out.println("中序遍历:" + arrayList.toString());
        return true;
    }

    // 通过中序遍历形成序列
    private void InOrderTraversal(Node node, ArrayList<E> arrayList) {
        if (node == null) {
            return;
        }
        InOrderTraversal(node.left, arrayList);
        arrayList.add((E) node.e);
        InOrderTraversal(node.right, arrayList);
    }

    // 判断是否是一棵平衡二叉树
    public boolean isBalancedTree() {
        return isBalanced(root);
    }

    // 通过递归遍历判断是否为平衡二叉树:判断每个结点的平衡因子的绝对值是否有大于1的存在
    private boolean isBalanced(Node node) {

        if (node == null) {
            return true;
        }
        // 获取该结点的平衡因子,并判断平衡因子的绝对值是否大于1
        int balanceFactor = getBalanceFactor(node);
        if (Math.abs(balanceFactor) > 1) {
            System.out.println("元素["+node.e + "] 平衡因子=" + balanceFactor+",跨越1");
            System.out.println("元素["+node.e+ "] 左子树的高度="+node.left.height+ ",右子树的高度="+node.right.height);
            return false;
        }
        // 遍历判断结点的左子树和右子树的各个结点
        return isBalanced(node.left) && isBalanced(node.right);
    }

    public static void main(String[] args) {
        // 界说一个数组
        Integer[] arr = {48, 30, 66, 21, 34, 57, 78, 14};
        // 将该数组构建成一个二分搜索树
        AVL<Integer> avl = new AVL<>();
        for (int i = 0; i < arr.length; i++) {
            avl.add(arr[i]);
        }
        // 判断当前的二叉树是否知足二分搜索树的界说
        boolean isBST = avl.isBST();
        boolean isBalance = avl.isBalancedTree();
        // 判断当前的树是否知足AVL界说
        if (isBST && isBalance) {
            System.out.println("该二叉树知足二分搜索树及平衡的条件,是AVL树!!!");
        } else {
            System.out.println("该二叉树不是AVL树;" + "是否知足二分搜索树条件:" + isBST + " ;是否知足平衡条件:" + isBalance);
        }

        // 给该AVL树加上一个结点,再次判断是否判断
        avl.add(10);
        // 判断当前的二叉树是否知足二分搜索树的界说
        isBST = avl.isBST();
        isBalance = avl.isBalancedTree();
        // 判断当前的树是否知足AVL界说
        if (isBST && isBalance) {
            System.out.println("该二叉树知足二分搜索树及平衡的条件,是AVL树!!!");
        } else {
            System.out.println("该二叉树不是AVL树;" + "是否知足二分搜索树条件:" + isBST + " ;是否知足平衡条件:" + isBalance);
        }
    }
}
  • 通过{48, 30, 66, 21, 34, 57, 78, 14}构建AVL树
    自已着手作图搞清楚AVL树 第5张

  • 给以上AVL树增添一个结点10,再次判断该树是否知足AVL的界说
    自已着手作图搞清楚AVL树 第6张

三、旋转操作

往AVL树中添加结点很可能会导致失去平衡,以是我们需要在每次插入结点后举行平衡的维护。损坏平衡性有如下四种情形:

3.1 L L--需要通过右旋操作
  • 在结点的左子树(L)的左孩子(L)添加新的结点,会导致失去平衡:
    自已着手作图搞清楚AVL树 第7张
  • 通过右旋操作(顺时针转)将平衡因子大于1的结点举行调整

自已着手作图搞清楚AVL树 第8张

  • 完整动画演示
    自已着手作图搞清楚AVL树 第9张
  • 代码处置
// 右旋(顺时针转)
    private Node rightRotate(Node y) {
        Node x = y.left;
        Node T = x.right;

        // 向右旋转历程
        x.right = y;
        y.left = T;

        // 更新height
        y.height = setHeight(y);
        System.out.println("元素[" + y.e + "] 右旋后更新高度: height=" + y.height);
        x.height = setHeight(x);
        System.out.println("元素[" + x.e + "] 更新高度: height=" + x.height);

        return x;
    }
3.2 R R--需要通过左旋操作
  • 在结点的右子树(R)的右孩子(R)添加新的结点,会导致失去平衡:

自已着手作图搞清楚AVL树 第10张

  • 通过左旋操作(逆时针转)将平衡因子大于1的结点举行调整
    自已着手作图搞清楚AVL树 第11张
  • 完整动画演示
    自已着手作图搞清楚AVL树 第12张
  • 代码处置
 // 左旋(逆时针转)
    private Node leftRotate(Node y) {
        Node x = y.right;
        Node T = x.left;

        // 向左旋转历程
        x.left = y;
        y.right = T;

        // 更新height
        y.height = setHeight(y);
        System.out.println("元素[" + y.e + "] 左旋后更新高度: height=" + y.height);
        x.height = setHeight(x);
        System.out.println("元素[" + x.e + "] 更新高度: height=" + x.height);

        return x;
    }
3.3 L R--需要先通过左旋再右旋操作
  • 在结点的左子树(L)的右孩子(R)添加新的结点,会导致失去平衡:
    自已着手作图搞清楚AVL树 第13张
  • 先通过左子结点的左旋操作(逆时针转)转成LL形式,再通过右旋操作(顺时针转)将平衡因子大于1的结点举行调整
    自已着手作图搞清楚AVL树 第14张
  • 完整动画演示
    自已着手作图搞清楚AVL树 第15张
2.4 R L--需要先通过右旋再左旋操作
  • 在结点的右子树(R)的左孩子(L)添加新的结点,会导致失去平衡:
    自已着手作图搞清楚AVL树 第16张
  • 先通过右子结点的右旋操作(顺时针转)转成RR形式,再通过左旋操作(逆时针转)将平衡因子大于1的结点举行调整
    自已着手作图搞清楚AVL树 第17张
  • 完整动画演示
    自已着手作图搞清楚AVL树 第18张

四、AVL树完整代码实现

/**
 * AVL树
 *
 * @param <E> 元素
 * @author zhuhuix
 * @date 2020-07-21
 */
public class AVL<E extends Comparable<E>> {

    // 私有内部类-树结点
    private class Node<E> {
        E e;
        Node left, right;
        // 高度
        int height;

        Node(E e) {
            this.e = e;
            this.left = null;
            this.right = null;
            this.height = 1;
        }

    }

    // 根结点
    private Node root;

    // 获得节点node的高度
    private int getHeight(Node node) {
        if (node == null) {
            return 0;
        }
        return node.height;
    }

    // 盘算结点的高度
    private int setHeight(Node node) {
        return node.height = Math.max(getHeight(node.left), getHeight(node.right)) + 1;
    }

    // 获得节点node的平衡因子
    private int getBalanceFactor(Node node) {
        if (node == null) {
            return 0;
        }
        return getHeight(node.left) - getHeight(node.right);
    }

    // 右旋(顺时针转)
    private Node rightRotate(Node y) {
        Node x = y.left;
        Node T = x.right;

        // 向右旋转历程
        x.right = y;
        y.left = T;

        // 更新height
        y.height = setHeight(y);
        System.out.println("元素[" + y.e + "] 右旋后更新高度: height=" + y.height);
        x.height = setHeight(x);
        System.out.println("元素[" + x.e + "] 更新高度: height=" + x.height);

        return x;
    }

    // 左旋(逆时针转)
    private Node leftRotate(Node y) {
        Node x = y.right;
        Node T = x.left;

        // 向左旋转历程
        x.left = y;
        y.right = T;

        // 更新height
        y.height = setHeight(y);
        System.out.println("元素[" + y.e + "] 左旋后更新高度: height=" + y.height);
        x.height = setHeight(x);
        System.out.println("元素[" + x.e + "] 更新高度: height=" + x.height);

        return x;
    }

    // 增添元素
    public void add(E e) {
        root = addNode(root, e);
    }

    // 通过递归算法遍历现有结点,将新结点插入到合适的位置
    private Node addNode(Node node, E element) {

        if (node == null) {
            System.out.println("新增元素[" + element + "] height=1");
            return new Node(element);
        }

        // 新加入元素小于结点值,往左子树增添
        if (element.compareTo((E) node.e) < 0) {
            node.left = addNode(node.left, element);
            // 新加入元素大于结点值,往右子树增添
        } else if (element.compareTo((E) node.e) > 0) {
            node.right = addNode(node.right, element);
        } else // element.compareTo(node.e) == 0
        {
            node.e = element;
        }
        // 更新height
        node.height = setHeight(node);
        System.out.println("元素[" + node.e + "] 更新高度: height=" + node.height);

        // 盘算平衡因子
        int balanceFactor = getBalanceFactor(node);
        if (node != null) {
            System.out.println("元素[" + node.e + "] "
                    + "左子结点为:[" + (node.left == null ? "" : node.left.e) + "]"
                    + "右子结点为:[" + (node.right == null ? "" : node.right.e) + "]"
                    + ",balanceFactor=" + balanceFactor);
        }

        // 平衡维护
        if (balanceFactor > 1 && getBalanceFactor(node.left) >= 0) {
            System.out.println("元素[" + node.e + "] balanceFactor=" + balanceFactor + ",举行右旋");
            return rightRotate(node);
        }

        if (balanceFactor < -1 && getBalanceFactor(node.right) <= 0) {
            System.out.println("元素[" + node.e + "] balanceFactor=" + balanceFactor + ",举行左旋");
            return leftRotate(node);
        }

        if (balanceFactor > 1 && getBalanceFactor(node.left) < 0) {
            System.out.print("元素[" + node.e + "] balanceFactor=" + balanceFactor + " 先将[" + node.e + "的左子结点" + node.left.e + "] 举行左旋");
            node.left = leftRotate(node.left);
            System.out.println("再将元素[" + node.e + "] 举行右旋");
            return rightRotate(node);
        }

        if (balanceFactor < -1 && getBalanceFactor(node.right) > 0) {
            System.out.print("元素[" + node.e + "] balanceFactor=" + balanceFactor + " 先将[" + node.e + "的右子结点" + node.right.e + "] 举行右旋");
            node.right = rightRotate(node.right);
            System.out.println("再将元素[" + node.e + "] 举行左旋");
            return leftRotate(node);
        }

        return node;
    }

    // 判断二叉树是否为二分搜索树:从根结点中序遍历形成的序列是否从小到大有序排列
    public boolean isBST() {
        ArrayList<E> arrayList = new ArrayList<>();
        InOrderTraversal(root, arrayList);
        for (int i = 0; i < arrayList.size() - 1; i++) {
            // 相邻两个元素对照,若是前一个元素大于后一个元素,则不为二分搜索树
            if (arrayList.get(i).compareTo(arrayList.get(i + 1)) > 0) {
                return false;
            }
        }
        System.out.println("中序遍历:" + arrayList.toString());
        return true;
    }

    // 通过中序遍历形成序列
    private void InOrderTraversal(Node node, ArrayList<E> arrayList) {
        if (node == null) {
            return;
        }
        InOrderTraversal(node.left, arrayList);
        arrayList.add((E) node.e);
        InOrderTraversal(node.right, arrayList);
    }

    // 前序遍历打印
    public void preOrderTraversal() {
        ArrayList<E> arrayList = new ArrayList<>();
        preOrderTraversal(root, arrayList);
        System.out.println("前序遍历" + arrayList);
    }

    // 通过前序遍历形成序列
    private void preOrderTraversal(Node node, ArrayList<E> arrayList) {
        if (node == null) {
            return;
        }
        arrayList.add((E) node.e);
        preOrderTraversal(node.left, arrayList);
        preOrderTraversal(node.right, arrayList);
    }

    // 判断是否是一棵平衡二叉树
    public boolean isBalancedTree() {
        return isBalanced(root);
    }

    // 通过递归遍历判断是否为平衡二叉树:判断每个结点的平衡因子的绝对值是否有大于1的存在
    private boolean isBalanced(Node node) {

        if (node == null) {
            return true;
        }
        // 获取该结点的平衡因子,并判断平衡因子的绝对值是否大于1
        int balanceFactor = getBalanceFactor(node);
        if (Math.abs(balanceFactor) > 1) {
            System.out.println("元素[" + node.e + "] 平衡因子=" + balanceFactor + ",跨越1");
            System.out.println("元素[" + node.e + "] 左子树的高度=" + node.left.height + ",右子树的高度=" + node.right.height);
            return false;
        }
        // 遍历判断结点的左子树和右子树的各个结点
        return isBalanced(node.left) && isBalanced(node.right);
    }

    public static void main(String[] args) {
        // 界说一个数组
        Integer[] arr = {48, 30, 66, 21, 34, 57, 78, 14};
        // 将该数组构建成一个二分搜索树
        AVL<Integer> avl = new AVL<>();
        for (int i = 0; i < arr.length; i++) {
            avl.add(arr[i]);
        }
        // 判断当前的二叉树是否知足二分搜索树的界说
        boolean isBST = avl.isBST();
        boolean isBalance = avl.isBalancedTree();
        // 判断当前的树是否知足AVL界说
        if (isBST && isBalance) {
            System.out.println("该二叉树知足二分搜索树及平衡的条件,是AVL树!!!");
        } else {
            System.out.println("该二叉树不是AVL树;" + "是否知足二分搜索树条件:" + isBST + " ;是否知足平衡条件:" + isBalance);
        }


        // 给该AVL树加上一个结点,再次判断是否判断
        avl.add(10);
        // 判断当前的二叉树是否知足二分搜索树的界说
        isBST = avl.isBST();
        isBalance = avl.isBalancedTree();
        // 判断当前的树是否知足AVL界说
        if (isBST && isBalance) {
            System.out.println("该二叉树知足二分搜索树及平衡的条件,是AVL树!!!");
        } else {
            System.out.println("该二叉树不是AVL树;" + "是否知足二分搜索树条件:" + isBST + " ;是否知足平衡条件:" + isBalance);
        }

    }
}

  • 构建AVL树历程
    自已着手作图搞清楚AVL树 第19张
  • 添加结点AVL树平衡历程
    自已着手作图搞清楚AVL树 第20张
,

环球UG

欢迎进入环球UG官网(UG环球):www.ugbet.us,环球UG官方网站:www.ugbet.net开放环球UG网址访问、环球UG会员注册、环球UG代理申请、环球UG电脑客户端、环球UG手机版下载等业务。

皇冠体育声明:该文看法仅代表作者自己,与本平台无关。转载请注明:自已着手作图搞清楚AVL树

网友评论

  • (*)

最新评论

文章归档

站点信息

  • 文章总数:668
  • 页面总数:0
  • 分类总数:8
  • 标签总数:1160
  • 评论总数:260
  • 浏览总数:7622