Java-AVL树

转x33g5p2x  于2022-02-07 转载在 Java  
字(7.6k)|赞(0)|评价(0)|浏览(407)

在线可视化AVL树演示

https://www.cs.usfca.edu/~galles/visualization/AVLtree.html

AVL树简介

AVL树其实就是二叉查找树,不同的是在二叉查找树的基础上进行了加强,弥补了二叉树会有可能退化为链表情况

AVL的核心原理就是自璇,自动调整树的高度,使树始终保存接近完全二叉树的结构,这样就能最大化利用二叉树查找树的查询特性完成高效处理,但是缺点也是很明显增加和删除就会慢上很多

AVL树必要条件：

条件一：它必须是二叉查找树。
条件二：每个节点的左子树和右子树的高度最多为1,否则就要进行自璇来调整

AVL树相关概念

平衡因子

将二叉树上节点的左子树高度减去右子树高度的值称为该节点的平衡因子BF(Balance Factor)。一共有三种正常情况(0 ,1,-1),只要平衡因子不是这三种情况那么就是需要进行树的平衡了 ,值大于1那么就是树左节点深了,需要进行右旋,如果小于-1那么就是右节点深了,需要左旋,当然不止这两种可能,一共有四种可能性下面会详细介绍的

右单旋

]

左单旋

双旋-左右

先小节点进行左旋

然后在进行大节点的右旋

双旋-右左

先小节点进行右旋

然后在进行大节点的右旋

经验之谈

我刚接触这个avl树的时候一脸懵逼,树怎么旋转?,节点直接怎么交换呢?
然后我就去看数据结构书,和看大神文章发现还是没卵用,总是是懂非懂的,但是直到有一天,一个电闪雷鸣的夜里,我下定决看图看代码,看图看代码,看图看代码,然后终于领悟了,最关键的地方,就是怎么处理树的高度,让我们知道树不平衡和树是平衡的,之后在对应不同的场景使用不同的旋转策略就行了

代码实现

使用递归实现AVL方式,最为简单,其他方式都太复杂了不好理解也不好写,并且效率也没有递归快

  1. package com.tree.avltree;
  3. /**
  4.  * AVL树
  5.  *
  6.  * @author huanmin
  8.  */
  10. public class AVLTree<T extends Comparable<T>> {
  11.     private AVLTreeNode<T> mRoot;    // 根结点
  13.     // AVL树的节点(内部类)
  14.     class AVLTreeNode<T extends Comparable<T>> {
  15.         T key;                // 关键字(键值)
  16.         int height;         // 高度
  17.         AVLTreeNode<T> left;    // 左孩子
  18.         AVLTreeNode<T> right;    // 右孩子
  20.         public AVLTreeNode(T key, AVLTreeNode<T> left, AVLTreeNode<T> right) {
  21.             this.key = key;
  22.             this.left = left;
  23.             this.right = right;
  24.             this.height = 0;
  25.         }
  26.     }
  28.     // 构造函数
  29.     public AVLTree() {
  30.         mRoot = null;
  31.     }
  33.     /*
  34.      * 获取树的高度
  35.      */
  36.     private int height(AVLTreeNode<T> tree) {
  37.         if (tree != null) {
  38.             return tree.height;
  39.         }
  41.         return 0;
  42.     }
  44.     public int height() {
  45.         return height(mRoot);
  46.     }
  48.     /*
  49.      * 比较两个值的大小
  50.      */
  51.     private int max(int a, int b) {
  52.         return a>b ? a : b;
  53.     }
  55.     /*
  56.      * 前序遍历"AVL树"
  57.      */
  58.     private void preOrder(AVLTreeNode<T> tree) {
  59.         if(tree != null) {
  60.             System.out.print(tree.key+" ");
  61.             preOrder(tree.left);
  62.             preOrder(tree.right);
  63.         }
  64.     }
  66.     public void preOrder() {
  67.         preOrder(mRoot);
  68.     }
  70.     /*
  71.      * 中序遍历"AVL树"
  72.      */
  73.     private void inOrder(AVLTreeNode<T> tree) {
  74.         if(tree != null)
  75.         {
  76.             inOrder(tree.left);
  77.             System.out.print(tree.key+" ");
  78.             inOrder(tree.right);
  79.         }
  80.     }
  82.     public void inOrder() {
  83.         inOrder(mRoot);
  84.     }
  86.     /*
  87.      * 后序遍历"AVL树"
  88.      */
  89.     private void postOrder(AVLTreeNode<T> tree) {
  90.         if(tree != null) {
  91.             postOrder(tree.left);
  92.             postOrder(tree.right);
  93.             System.out.print(tree.key+" ");
  94.         }
  95.     }
  97.     public void postOrder() {
  98.         postOrder(mRoot);
  99.     }
  101.     /*
  102.      * (递归实现)查找"AVL树x"中键值为key的节点
  103.      */
  104.     private AVLTreeNode<T> search(AVLTreeNode<T> x, T key) {
  105.         if (x==null) {
  106.             return x;
  107.         }
  109.         int cmp = key.compareTo(x.key);
  110.         if (cmp < 0) {
  111.             return search(x.left, key);
  112.         } else if (cmp > 0) {
  113.             return search(x.right, key);
  114.         } else {
  115.             return x;
  116.         }
  117.     }
  119.     public AVLTreeNode<T> search(T key) {
  120.         return search(mRoot, key);
  121.     }
  123.     /*
  124.      * (非递归实现)查找"AVL树x"中键值为key的节点
  125.      */
  126.     private AVLTreeNode<T> iterativeSearch(AVLTreeNode<T> x, T key) {
  127.         while (x!=null) {
  128.             int cmp = key.compareTo(x.key);
  130.             if (cmp < 0) {
  131.                 x = x.left;
  132.             } else if (cmp > 0) {
  133.                 x = x.right;
  134.             } else {
  135.                 return x;
  136.             }
  137.         }
  139.         return x;
  140.     }
  142.     public AVLTreeNode<T> iterativeSearch(T key) {
  143.         return iterativeSearch(mRoot, key);
  144.     }
  146.     /*
  147.      * 查找最小结点：返回tree为根结点的AVL树的最小结点。
  148.      */
  149.     private AVLTreeNode<T> minimum(AVLTreeNode<T> tree) {
  150.         if (tree == null) {
  151.             return null;
  152.         }
  154.         while(tree.left != null) {
  155.             tree = tree.left;
  156.         }
  157.         return tree;
  158.     }
  160.     public T minimum() {
  161.         AVLTreeNode<T> p = minimum(mRoot);
  162.         if (p != null) {
  163.             return p.key;
  164.         }
  166.         return null;
  167.     }
  169.     /*
  170.      * 查找最大结点：返回tree为根结点的AVL树的最大结点。
  171.      */
  172.     private AVLTreeNode<T> maximum(AVLTreeNode<T> tree) {
  173.         if (tree == null) {
  174.             return null;
  175.         }
  177.         while(tree.right != null) {
  178.             tree = tree.right;
  179.         }
  180.         return tree;
  181.     }
  183.     public T maximum() {
  184.         AVLTreeNode<T> p = maximum(mRoot);
  185.         if (p != null) {
  186.             return p.key;
  187.         }
  189.         return null;
  190.     }
  192.     /*
  193.      * LL：左左对应的情况(左单旋转)。
  194.      *
  195.      * 返回值：旋转后的根节点
  196.      */
  197.     private AVLTreeNode<T> leftLeftRotation(AVLTreeNode<T> k2) {
  198.         AVLTreeNode<T> k1;
  200.         k1 = k2.left;
  201.         k2.left = k1.right;
  202.         k1.right = k2;
  204.         k2.height = max( height(k2.left), height(k2.right)) + 1;
  205.         k1.height = max( height(k1.left), k2.height) + 1;
  207.         return k1;
  208.     }
  210.     /*
  211.      * RR：右右对应的情况(右单旋转)。
  212.      *
  213.      * 返回值：旋转后的根节点
  214.      */
  215.     private AVLTreeNode<T> rightRightRotation(AVLTreeNode<T> k1) {
  216.         AVLTreeNode<T> k2;
  218.         k2 = k1.right;
  219.         k1.right = k2.left;
  220.         k2.left = k1;
  222.         k1.height = max( height(k1.left), height(k1.right)) + 1;
  223.         k2.height = max( height(k2.right), k1.height) + 1;
  225.         return k2;
  226.     }
  228.     /*
  229.      * LR：左右对应的情况(左双旋转)。
  230.      *
  231.      * 返回值：旋转后的根节点
  232.      */
  233.     private AVLTreeNode<T> leftRightRotation(AVLTreeNode<T> k3) {
  234.         k3.left = rightRightRotation(k3.left);
  236.         return leftLeftRotation(k3);
  237.     }
  239.     /*
  240.      * RL：右左对应的情况(右双旋转)。
  241.      *
  242.      * 返回值：旋转后的根节点
  243.      */
  244.     private AVLTreeNode<T> rightLeftRotation(AVLTreeNode<T> k1) {
  245.         k1.right = leftLeftRotation(k1.right);
  247.         return rightRightRotation(k1);
  248.     }
  250.     /*
  251.      * 将结点插入到AVL树中，并返回根节点
  252.      *
  253.      * 参数说明：
  254.      *     tree AVL树的根结点
  255.      *     key 插入的结点的键值
  256.      * 返回值：
  257.      *     根节点
  258.      */
  259.     private AVLTreeNode<T> insert(AVLTreeNode<T> tree, T key) {
  260.         if (tree == null) {
  261.             // 新建节点
  262.             tree = new AVLTreeNode<T>(key, null, null);
  263.         } else {
  264.             //key大于tree.key那么 返回1 小于返回-1 等于返回0
  265.             int cmp = key.compareTo(tree.key);
  266.             if (cmp < 0) {    // 应该将key插入到"tree的左子树"的情况
  267.                 tree.left = insert(tree.left, key);
  268.                 // 插入节点后，若AVL树失去平衡，则进行相应的调节。
  269.                 if (height(tree.left) - height(tree.right) == 2) {
  270.                     //(左子树太深了)进行调整
  271.                     if (key.compareTo(tree.left.key) < 0) {
  272.                         //单旋
  273.                         tree = leftLeftRotation(tree);
  274.                     } else {
  275.                         //双选
  276.                         tree = leftRightRotation(tree);
  277.                     }
  278.                 }
  279.             } else if (cmp > 0) {    // 应该将key插入到"tree的右子树"的情况
  280.                 tree.right = insert(tree.right, key);
  281.                 // 插入节点后，若AVL树失去平衡，则进行相应的调节。
  282.                 if (height(tree.right) - height(tree.left) == 2) {
  283.                     //(右子树太深了)进行调整
  284.                     if (key.compareTo(tree.right.key) > 0) {
  285.                         //单旋
  286.                         tree = rightRightRotation(tree);
  287.                     } else {
  288.                         //双选
  289.                         tree = rightLeftRotation(tree);
  290.                     }
  291.                 }
  292.             } else {    // cmp==0   解决办法可以添加链表的方式,这里就不演示了
  293.                 System.out.println("添加失败：不允许添加相同的节点！");
  294.             }
  295.         }
  296.         //在递归进入时候对每一个节点高度+1  ,递归返归时候,拿上个节点的值+1
  297.         tree.height = max( height(tree.left), height(tree.right)) + 1;
  299.         return tree;
  300.     }
  302.     public void insert(T key) {
  303.         mRoot = insert(mRoot, key);
  304.     }
  306.     /*
  307.      * 删除结点(z)，返回根节点
  308.      *
  309.      * 参数说明：
  310.      *     tree AVL树的根结点
  311.      *     z 待删除的结点
  312.      * 返回值：
  313.      *     根节点
  314.      */
  315.     private AVLTreeNode<T> remove(AVLTreeNode<T> tree, AVLTreeNode<T> z) {
  316.         // 根为空 或者 没有要删除的节点，直接返回null。
  317.         if (tree==null || z==null) {
  318.             return null;
  319.         }
  321.         int cmp = z.key.compareTo(tree.key);
  322.         if (cmp < 0) {        // 待删除的节点在"tree的左子树"中
  323.             tree.left = remove(tree.left, z);
  324.             // 删除节点后，若AVL树失去平衡，则进行相应的调节。
  325.             if (height(tree.right) - height(tree.left) == 2) {
  326.                 AVLTreeNode<T> r =  tree.right;
  327.                 if (height(r.left) > height(r.right)) {
  328.                     tree = rightLeftRotation(tree);
  329.                 } else {
  330.                     tree = rightRightRotation(tree);
  331.                 }
  332.             }
  333.         } else if (cmp > 0) {    // 待删除的节点在"tree的右子树"中
  334.             tree.right = remove(tree.right, z);
  335.             // 删除节点后，若AVL树失去平衡，则进行相应的调节。
  336.             if (height(tree.left) - height(tree.right) == 2) {
  337.                 AVLTreeNode<T> l =  tree.left;
  338.                 if (height(l.right) > height(l.left)) {
  339.                     tree = leftRightRotation(tree);
  340.                 } else {
  341.                     tree = leftLeftRotation(tree);
  342.                 }
  343.             }
  344.         } else {    // tree是对应要删除的节点。
  345.             // tree的左右孩子都非空
  346.             if ((tree.left!=null) && (tree.right!=null)) {
  347.                 if (height(tree.left) > height(tree.right)) {
  348.                     // 如果tree的左子树比右子树高；
  349.                     // 则(01)找出tree的左子树中的最大节点
  350.                     //   (02)将该最大节点的值赋值给tree。
  351.                     //   (03)删除该最大节点。
  352.                     // 这类似于用"tree的左子树中最大节点"做"tree"的替身；
  353.                     // 采用这种方式的好处是：删除"tree的左子树中最大节点"之后，AVL树仍然是平衡的。
  354.                     AVLTreeNode<T> max = maximum(tree.left);
  355.                     tree.key = max.key;
  356.                     tree.left = remove(tree.left, max);
  357.                 } else {
  358.                     // 如果tree的左子树不比右子树高(即它们相等，或右子树比左子树高1)
  359.                     // 则(01)找出tree的右子树中的最小节点
  360.                     //   (02)将该最小节点的值赋值给tree。
  361.                     //   (03)删除该最小节点。
  362.                     // 这类似于用"tree的右子树中最小节点"做"tree"的替身；
  363.                     // 采用这种方式的好处是：删除"tree的右子树中最小节点"之后，AVL树仍然是平衡的。
  364.                     AVLTreeNode<T> min = maximum(tree.right);
  365.                     tree.key = min.key;
  366.                     tree.right = remove(tree.right, min);
  367.                 }
  368.             } else {
  369.                 AVLTreeNode<T> tmp = tree;
  370.                 tree = (tree.left!=null) ? tree.left : tree.right;
  371.                 tmp = null;
  372.             }
  373.         }
  375.         return tree;
  376.     }
  378.     public void remove(T key) {
  379.         AVLTreeNode<T> z;
  381.         if ((z = search(mRoot, key)) != null) {
  382.             mRoot = remove(mRoot, z);
  383.         }
  384.     }
  386.     /*
  387.      * 销毁AVL树
  388.      */
  389.     private void destroy(AVLTreeNode<T> tree) {
  390.         if (tree==null) {
  391.             return ;
  392.         }
  394.         if (tree.left != null) {
  395.             destroy(tree.left);
  396.         }
  397.         if (tree.right != null) {
  398.             destroy(tree.right);
  399.         }
  401.         tree = null;
  402.     }
  404.     public void destroy() {
  405.         destroy(mRoot);
  406.     }
  408.     /*
  409.      * 打印"二叉查找树"
  410.      *
  411.      * key        -- 节点的键值
  412.      * direction  --  0，表示该节点是根节点;
  413.      *               -1，表示该节点是它的父结点的左孩子;
  414.      *                1，表示该节点是它的父结点的右孩子。
  415.      */
  416.     private void print(AVLTreeNode<T> tree, T key, int direction) {
  417.         if(tree != null) {
  418.             if(direction==0)    // tree是根节点
  419.             {
  420.                 System.out.printf("%2d is root\n", tree.key, key);
  421.             } else                // tree是分支节点
  422.             {
  423.                 System.out.printf("%2d is %2d's %6s child\n", tree.key, key, direction==1?"right" : "left");
  424.             }
  426.             print(tree.left, tree.key, -1);
  427.             print(tree.right,tree.key,  1);
  428.         }
  429.     }
  431.     public void print() {
  432.         if (mRoot != null) {
  433.             print(mRoot, mRoot.key, 0);
  434.         }
  435.     }
  436. }

点赞 -收藏-关注-便于以后复习和收到最新内容有其他问题在评论区讨论-或者私信我-收到会在第一时间回复如有侵权，请私信联系我感谢,配合,希望我的努力对你有帮助^_^

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/weixin_45203607/article/details/122580992

内容来源于网络，如有侵权，请联系作者删除！

Java数据结构算法后端

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com