AVL树的基本操作与实现

最新推荐文章于 2021-08-25 22:53:34 发布
最新推荐文章于 2021-08-25 22:53:34 发布
阅读量204 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41241541/article/details/95787407
版权

package BST树;

import java.util.TreeSet;

class AVLNode<T extends Comparable>{
private T data;
private AVLNode left;
private AVLNode right;
private int height; // 记录节点当前的高度值

public AVLNode(T data, AVLNode<T> left, AVLNode<T> right, int height) {
    this.data = data;
    this.left = left;
    this.right = right;
    this.height = height;
}

public T getData() {
    return data;
}

public void setData(T data) {
    this.data = data;
}

public AVLNode<T> getLeft() {
    return left;
}

public void setLeft(AVLNode<T> left) {
    this.left = left;
}

public AVLNode<T> getRight() {
    return right;
}

public void setRight(AVLNode<T> right) {
    this.right = right;
}

public int getHeight() {
    return height;
}

public void setHeight(int height) {
    this.height = height;
}

}

/**

  • 描述: 平衡二叉搜索树

  • 平衡：节点左右子树的高度差不超过1

  • 引入了四种旋转方式：

  • 1.左孩子的左子树太高： 右旋转操作

  •    40              30

  •  30      =>     20    40    =>   node,child

  • 20

  • 2.右孩子的右子树太高： 左旋转操作

  • 40                  50

  •    50      =>   40       60   =>   node,child

  •       60

  • 3.左孩子的右子树太高

  •  40             40             30

  • 20 => 30 => 20 40

  •  30         20

  • 4.右孩子的左子树太高

  • 40 40 50

  •   60   =>        50       => 40        60

  • 50 60

  • 问题：

  • 1.AVL是不是一个二叉搜索树？

  • 2.AVL是不是一颗平衡树？

  • 3.树的平衡指的是什么？

  • 4.AVL树是怎么旋转的？

  • 5.AVL树最差，最好，平均 增删查时间复杂度？

  • 6.AVL树在插入删除过程中，最差的情况下，需要旋转的次数是多少次？O(log2n) 删除 插入 最多2次搞定

  • AVL为了保持树的平衡，而做的旋转操作过多，当数据量大的时候，AVL树的增加，删除时间花费越来越大

  • @Author shilei

  • @Date 2019/7/3
    */
    public class AVL<T extends Comparable> {
    private AVLNode root;

    public AVL(){
    this.root = null;
    }

    /**

    • 递归实现AVL树的插入操作
    • @param data
      */
      public void insert(T data){
      this.root = insert(this.root, data);
      }

    /**

    • 以参数root为起始节点，搜索一个合适的位置添加data，然后把子树的根节点返回

    • @param root

    • @param data

    • @return
      */
      private AVLNode insert(AVLNode root, T data) {
      if(root == null){
      return new AVLNode<>(data, null, null, 1);
      }

      if(root.getData().compareTo(data) > 0){
      root.setLeft(insert(root.getLeft(), data));
      // 判断root节点是否失衡 #1
      if(height(root.getLeft()) - height(root.getRight()) > 1){
      if(height(root.getLeft().getLeft())
      >= height(root.getLeft().getRight())){
      // 左孩子的左子树太高
      root = rightRotate(root);
      } else {
      // 左孩子的右子树太高
      root = leftBalance(root);
      }
      }
      } else if(root.getData().compareTo(data) < 0){
      root.setRight(insert(root.getRight(), data));
      // 判断root节点是否失衡 #2
      if(height(root.getRight()) - height(root.getLeft()) > 1){
      if(height(root.getRight().getRight())
      >= height(root.getRight().getLeft())){
      // 右孩子的右子树太高
      root = leftRotate(root);
      } else {
      // 右孩子的左子树太高
      root = rightBalance(root);
      }
      }
      }

      // 递归回溯过程中，更新节点的高度值 #3
      root.setHeight(maxHeight(root.getLeft(), root.getRight()) + 1);
      return root;
      }

    /**

    • 实现AVL树的递归删除
    • @param data
      */
      public void remove(T data){
      this.root = remove(this.root, data);
      }

    private AVLNode remove(AVLNode root, T data) {
    if(root == null){
    return null;
    }

     if(root.getData().compareTo(data) > 0){
     root.setLeft(remove(root.getLeft(), data));
     // #1
     if(height(root.getRight()) - height(root.getLeft()) > 1){
         if(height(root.getRight().getRight())
                 >= height(root.getRight().getLeft())){
             root = leftRotate(root);
         } else {
             root= rightBalance(root);
         }
     }
 } else if(root.getData().compareTo(data) < 0){
     // #2
     root.setRight(remove(root.getRight(), data));
     if(height(root.getLeft()) - height(root.getRight()) > 1){
         if(height(root.getLeft().getLeft())
                 >= height(root.getLeft().getRight())){
             root = rightRotate(root);
         } else {
             root= leftBalance(root);
         }
     }
 } else {
     if(root.getLeft() != null && root.getRight() != null){
         // #3 左右子树哪个高，删除哪个，为了防止删除带来的旋转操作，提高效率
         if(height(root.getLeft()) >= height(root.getRight())){
             // 用前驱替换
             AVLNode<T> pre = root.getLeft();
             while(pre.getRight() != null){
                 pre = pre.getRight();
             }
             root.setData(pre.getData());
             root.setLeft(remove(root.getLeft(), pre.getData())); //删除前驱
         } else {
             // 用后继替换
             AVLNode<T> post = root.getRight();
             while(post.getLeft() != null){
                 post = post.getLeft();
             }
             root.setData(post.getData());
             root.setRight(remove(root.getRight(), post.getData())); // 删除后继
         }
     } else {
         if(root.getLeft() != null){
             return root.getLeft();
         } else if(root.getRight() != null){
             return root.getRight();
         } else {
             return null;
         }
     }
 }

 // 递归回溯过程中，更新节点的高度值 #4
 root.setHeight(maxHeight(root.getLeft(), root.getRight()) + 1);
 return root;

    }

    /**

    • 以参数node为根节点进行左旋操作，把旋转后的树的根节点返回
    • @param node
    • @return
      */
      private AVLNode leftRotate(AVLNode node){
      AVLNode child = node.getRight();
      node.setRight(child.getLeft());
      child.setLeft(node);
      node.setHeight(maxHeight(node.getLeft(), node.getRight()) + 1);
      child.setHeight(maxHeight(child.getLeft(), child.getRight()) + 1);
      return child;
      }

    /**

    • 以参数node为根节点进行右旋操作，把旋转后的树的根节点返回
    • @param node
    • @return
      */
      private AVLNode rightRotate(AVLNode node){
      AVLNode child = node.getLeft();
      node.setLeft(child.getRight());
      child.setRight(node);
      node.setHeight(maxHeight(node.getLeft(), node.getRight()) + 1);
      child.setHeight(maxHeight(child.getLeft(), child.getRight()) + 1);
      return child;
      }

    /**

    • 以参数node为根节点进行左平衡操作，把旋转后的树的根节点返回
    • @param node
    • @return
      */
      private AVLNode leftBalance(AVLNode node){
      node.setLeft(leftRotate(node.getLeft()));
      return rightRotate(node);
      }

    /**

    • 以参数node为根节点进行右平衡操作，把旋转后的树的根节点返回
    • @param node
    • @return
      */
      private AVLNode rightBalance(AVLNode node){
      node.setRight(rightRotate(node.getRight()));
      return leftRotate(node);
      }

    /**

    • 获取node为根节点的树的高度
    • @param node
    • @return
      */
      private int height(AVLNode node){
      return node == null ? 0 : node.getHeight();
      }

    /**

    • 返回以node1和node2为根节点的子树高度的最大值
    • @param node1
    • @param node2
    • @return
      */
      private int maxHeight(AVLNode node1, AVLNode node2){
      int l = height(node1);
      int r = height(node2);
      return l > r ? l : r;
      }

    public static void main(String[] args) {
    AVL avl = new AVL<>();
    long begin=0, end=0;

     begin = System.currentTimeMillis();
 for (int i = 1; i <= 10; i++) {
     avl.insert(i);
 }

 avl.remove(10);
 avl.remove(9);
 avl.remove(5);
 end = System.currentTimeMillis();
 System.out.println("avl spend time:" + (end-begin) + "ms");

 /*TreeSet<Integer> ts = new TreeSet<>();
 begin = System.currentTimeMillis();
 for (int i = 1; i <= 10000000; i++) {
     ts.add(i);
 }
 end = System.currentTimeMillis();
 System.out.println("TreeSet spend time:" + (end-begin) + "ms");

 System.out.println();*/

    }
    }

秋&芸栀
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AVL树及其相关操作
qq_42106610的博客
05-08 326
概念：AVL树，又叫平衡二叉搜索树。是个叫AVL的人发明的。（嗯，姑且这么记忆吧。全称我也不知道叫啥）。首先它是个二叉搜索树，其次他平衡。也就是任何一个节点平衡因子都在区间[-1,1]。 高度：一棵树除去根节点的最大层数，也就是树根高度为0。 平衡因子：一个节点的左子树高度减去右子树高度。 ...
keyedset:基于 AVL 树的 KeyedSet
06-19
键控集 Java 的不可变集合类： KeyedSet - 使用显式键设置类。 基于AVL树。 CList - 经典的 cons-cell 列表，没有位置。 CodedList - CDR 编码列表。 数组 - 索引集合。 所有类目前都与 Java 6 兼容。
MFC 电话薄 通讯录 AVL树快速搜索
01-11
本程序为MFC开发的电话薄，其中使用AVL数实现快速搜索。同时可以分页查看电话信息。为各种C++或MFC初学者提供。
AVL树的旋转图解和简单实现
喵了个呜的博客
07-07 4万+
AVL树是带有平衡条件的查找二叉树。这个平衡条件要容易保持，而且他要保证树的深度为O(logN) 原文地址：http://blog.csdn.net/qq_25806863/article/details/74755131 平衡条件 一个最理想的平衡条件是左右两个子树的高度完全相等，但只有节点数量为2^n-1的树才满足这个条件（n是层数，2层要3个，3层要7个）。这个条件太严格，不好用。...
AVL 树原理及操作详解
W24的博客
11-12 515
我们已经证明了高度为 hhh 的二叉搜索树上的每个基本操作都可以在 O(h)O(h)O(h) 时间内完成，然而随着元素的插入和删除，二叉搜索树的高度是变化的。例如，如果 nnn 个关键字按照严格递增的次序被插入，则这棵树一定是高度为 nnn 的一条链，在这样的树上进行操作的时间性能是比较低的。也就是说，如果搜索树的高度较低时，这些集合操作会执行得较快；然而如果树的高度较高时，这些集合操作可能并不比在链表上执行的快。也就有了各种各样的 “平衡”搜索树。 AVL 树是最早的自平衡二叉树，相比于后来出现的平衡二叉
实现AVL tree 的基本操作
07-02
自己写的平衡树的构建及相关操作
AVL_tree.rar_AVL树
09-22
实现AVL树的基本操作。定义了AVL树、结点元素。程序开始时，调用MakeEmpty()函数 将AVL树初始化，然后调用MainMenue()函数进入菜单选择项，根据输入的选择 项判断调用相应的程序，实现相应的逻辑功能。
AVL树概述与讲解.pdf
最新发布
04-21
AVL树讲解 （1）关于AVL树的基本概念和概述 （2）数据结构的定义 （3）关键基本操作的具体实现 （4）应用
AVLTrees:Java中的AVL树实现
05-05
AVL树Java中的AVL树实现有两个基本操作，使用这些操作树本身会保持平衡。 左旋转。 右旋。 然后将有四种可能性左-左情况：— x是y的左子代，y是z的左子代。 左右案例：— x是y的右子代，y是z的左子代。 左右案例：—...
avl_tree.rar_AVL树_avl
09-22
avl树的插入删除调整等等基本操作及具体实现
AVL树实现的映射
01-26
avl实现的map映射， alv 树 map 映射 c++ 如有bug 请告知2821565468@qq.com
详细图文——AVL树
热门推荐
带翅膀的猫的博客
04-09 12万+
平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。快来学习吧！详细图文。
AVL树的插入与删除操作
J.的学习室
07-22 4385
AVL树是一种较老的数据结构，它的出现是为了解决了二叉查找树在最坏情况下的插入结果。 二叉查找树（以下称为二叉树）如果能以较好的插入序列来创建，使得树的结构趋于平衡，则其大部分操作都可以O(logN)的复杂度实现。但如果以类似{1,2,3,4,5,6,.....}这种已序序列来进行插入，那么形成的二叉树将是极不平衡的，甚至有可能只有左子树或只有右子树，这样的二叉树与链表是没有太大区别的，各种操作
AVL树的插入操作（四种情况）
PYH的博客
08-25 4276
主要内容为AVL树的插入操作（不包含重复值），主要分为四种情况
平衡树和 AVL (3) —— AVL 树删除节点
一角残叶的博客
02-11 655
1 平衡树删除节点 AVLTree.java package avltree; import java.util.ArrayList; public class AVLTree&lt;K extends Comparable&lt;K&gt;, V&gt; { public class Node { public K key; public V ...
AVL树和红黑树（map和set的底层实现）
海盗船长y的博客
04-26 1222
map和set的概念及使用 map和set的底层结构 map和set其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。 AVL树 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉...
AVL树的操作
myBarbell的博客
04-01 461
AVL（ Adelson-Velsky and Landis）树是一棵自平衡的二叉查找树BST（binary search tree），所谓二叉查找树就是：左子树结点值&lt;根节点值&lt;右子树结点值。在查找结点值时相对普通二叉树的查找可以进行剪枝处理，当待查找值小于当前结点值时，往左子树查找，当待查结点值大于当前结点值时往右子树查找，这样查找时总体能达到o(logn)的复杂度。但当二叉查找树...
AVL树的定义和基本操作
Ben的专栏
01-15 2964
AVL树是带有平衡的二叉查找树！一颗AVL树的每一个结点的左子树和右子树的深度最多只有1的差距，这就保持了这颗二叉树的平衡！很大程度的提高了树的使用效率！ 当我们对树进行一系列操作（插入、删除等）后，AVL树很可能就不能保持AVL的特性，所以在进行操作时，我们必须重新平衡这颗二叉树！ 我们把必须重新平衡的结点叫做α（这样可以减少很多文字，又好理解），由于任意结点最多只有两个儿子，因此出现高度不
python 用AVL树实现字典类型
05-17
AVL树是一种自平衡二叉搜索树，可以用来实现字典类型。在实现字典类型时，我们可以将键值对存储在AVL树的节点中，其中键作为节点的关键字，值则作为节点的附加数据。 下面是一个简单的AVL树实现字典类型的Python代码： ```python class AVLNode: def __init__(self, key, val): self.key = key self.val = val self.left = None self.right = None self.height = 1 class AVLTree: def __init__(self): self.root = None def insert(self, key, val): self.root = self._insert(self.root, key, val) def _insert(self, node, key, val): if not node: return AVLNode(key, val) if key < node.key: node.left = self._insert(node.left, key, val) elif key > node.key: node.right = self._insert(node.right, key, val) else: node.val = val node.height = 1 + max(self._height(node.left), self._height(node.right)) balance = self._get_balance(node) if balance > 1 and key < node.left.key: return self._right_rotate(node) if balance < -1 and key > node.right.key: return self._left_rotate(node) if balance > 1 and key > node.left.key: node.left = self._left_rotate(node.left) return self._right_rotate(node) if balance < -1 and key < node.right.key: node.right = self._right_rotate(node.right) return self._left_rotate(node) return node def search(self, key): node = self._search(self.root, key) if node: return node.val else: return None def _search(self, node, key): if not node: return None if key == node.key: return node if key < node.key: return self._search(node.left, key) else: return self._search(node.right, key) def _height(self, node): if not node: return 0 return node.height def _get_balance(self, node): if not node: return 0 return self._height(node.left) - self._height(node.right) def _left_rotate(self, node): new_root = node.right node.right = new_root.left new_root.left = node node.height = 1 + max(self._height(node.left), self._height(node.right)) new_root.height = 1 + max(self._height(new_root.left), self._height(new_root.right)) return new_root def _right_rotate(self, node): new_root = node.left node.left = new_root.right new_root.right = node node.height = 1 + max(self._height(node.left), self._height(node.right)) new_root.height = 1 + max(self._height(new_root.left), self._height(new_root.right)) return new_root ``` 在这个实现中，我们定义了AVLNode类来表示AVL树的节点。每个节点包含一个键、一个值、左右子树指针以及节点高度。AVLTree类是AVL树的实现，包含了插入、搜索、左旋和右旋等基本操作。 在insert操作中，我们首先按照二叉搜索树的规则找到要插入的位置。然后更新节点高度，并计算平衡因子。如果平衡因子超过了1或-1，我们就需要进行旋转来保持AVL树的平衡。 在search操作中，我们按照二叉搜索树的规则搜索键值对应的节点，并返回其值。 这个AVL树实现可以用来实现字典类型。我们可以将键值对存储在AVL树的节点中，并通过搜索操作来查找键对应的值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值