AVL树

最新推荐文章于 2024-06-10 20:39:17 发布
最新推荐文章于 2024-06-10 20:39:17 发布
阅读量265 收藏
点赞数
分类专栏： 算法/数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaobaixiongxiong/article/details/100847563
版权

AVL树

  • 给你一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在

 

上面BST（二叉排序树） 存在的问题分析:

  1. 左子树全部为空，从形式上看，更像一个单链表.
  2. 插入速度没有影响
  3. 查询速度明显降低(因为需要依次比较), 不能发挥BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢
  4. 解决方案-平衡二叉树(AVL)

平衡二叉树：（平衡二叉树的前提是二叉排序树）

平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树， 可以保证查询效率较高。

具有以下特点：

  • 它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，
  • 并且左右两个子树都是一棵平衡二叉树。
  • 平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。

递归求解二叉树的高度：

/** * 当前节点的树的高度 * @return */ public int height() { //左子树的高度和右子树的高度的最大值 return Math.max(leftNode == null?0:leftNode.height(),rightNode==null?0:rightNode.height())+1; } /** * 右子树的高度 * @return */ public int leftHeight() { if (leftNode == null) { return 0; } else { return leftNode.height(); } } /** * 右子树的高度 * @return */ public int rightHeight() { if (rightNode == null) { return 0; } else { return rightNode.height(); } }

AVL树的旋转：

/** * 左旋转BST */ private void leftRotate() { //创建一个新的节点 newNode (以4这个值创建) //,创建一个新的节点，值等于当前根节点的值 Node newLeft = new Node(value); //把新节点的左子树设置了当前节点的左子树 newLeft.leftNode=leftNode; //把新节点的右子树设置为当前节点的右子树的左子树 newLeft.rightNode=rightNode.leftNode; //把当前节点的值换为右子节点的值 value=rightNode.value; //把当前节点的右子树设置成右子树的右子树 rightNode=rightNode.rightNode; //把当前节点的左子树设置为新节点 leftNode=newLeft; } /** * 右旋转 */ public void rightRotate() { Node newNode = new Node(value); newNode.rightNode = rightNode; newNode.leftNode = leftNode.rightNode; value = leftNode.value; leftNode = leftNode.leftNode; rightNode = newNode; }

由于二叉排序树有可能出现类似的情况：所以需要双旋转

双旋转：

 

解决思路分析

  • 问题分析出来: 在满足右旋转条件时，要判断
  • 如果 是 左子树的 右子树高度 大于左子树的左子树时：
  • 就是 对 当前根节点的左子树，先进行 左旋转，
  • 然后， 在对当前根节点进行右旋转即可
  • 否则，直接对当前节点（根节点）进行右旋转.即可. 
    package binaryTree.AVL;

/**
 * @Author: 白雄雄
 * @Date: 2019/9/14 16:29
 */
public class AvlTreeDemo {
    public static void main(String[] args) {
        int[] arrays = {4,3,6,5,7,8};
        AvlTree avlTree = new AvlTree();
        for (int i = 0; i < arrays.length; i++) {
            avlTree.addNode(new Node(arrays[i]));
        }
        avlTree.infixOrder();

        int height = avlTree.getRoot().height();
        System.out.println(height);
        int leftHeight = avlTree.getRoot().leftHeight();
        int rightHeight = avlTree.getRoot().rightHeight();
        System.out.println(leftHeight+" "+rightHeight);
    }
}
/**
 * 二叉排序树
 */
class AvlTree{
    private Node root;

    public Node getRoot() {
        return root;
    }

    //添加节点
    public void addNode(Node node) {
        if (root == null) {
            this.root = node;
        } else {
            root.addNode(node);
        }
    }

    //中序遍历
    public void infixOrder() {
        if (root != null) {
            root.infixOrder();
        } else {
            System.out.println("二叉树为空");
        }
    }

    //查找节点
    public Node search(Node node) {
        if (root == null) {
            return null;
        } else {
            return this.root.search(node);
        }
    }

    //查找父节点
    public Node searchParent(Node node) {
        if (root == null) {
            return null;
        } else {
            return this.root.searchParent2(node);
        }
    }

    public void deleteNode(Node node) {
        if (this.root == null) {
            return;
        }
        Node targetNode = search(node);
        //没找到
        if (targetNode == null) {
            return;
        }
        //如果当前二叉树只有一个节点
        if (root.getLeftNode() == null && root.getRightNode() == null) {
            this.root = null;
        }
        //找到父节点
        Node parentNode = searchParent(node);
        //删除叶子节点
        if (targetNode.getRightNode() == null && targetNode.getLeftNode() == null) {
            //左叶子节点
            if (parentNode.getLeftNode() != null && parentNode.getLeftNode().getValue() == node.getValue()) {
                parentNode.setLeftNode(null);
            } else if (parentNode.getRightNode() != null && parentNode.getRightNode().getValue() == node.getValue()) {//右叶子节点
                parentNode.setRightNode(null);
            }
        } else if (targetNode.getRightNode() != null && targetNode.getLeftNode() != null) {//删除有两颗子树的节点
            Node minNode = delTargetRightTreeMin(targetNode);
            targetNode.setValue(minNode.getValue());//最小节点替换要删除的节点
        } else {//删除有一颗子树的节点
            if (targetNode.getLeftNode() != null) {
                if (parentNode == null) {//判断删除节点是否是父节点
                    this.root = targetNode.getLeftNode();
                } else{
                    if (parentNode.getLeftNode() == node) {
                        parentNode.setLeftNode(targetNode.getLeftNode());
                    } else {
                        parentNode.setRightNode(targetNode.getLeftNode());
                    }
                }
            } else {
                if (parentNode != null) {
                    if (parentNode.getLeftNode() == node) {
                        parentNode.setLeftNode(targetNode.getRightNode());
                    } else {
                        parentNode.setRightNode(targetNode.getRightNode());
                    }
                } else {
                    this.root = targetNode.getRightNode();
                }
            }
        }
    }

    /**
     * 删除以要删除节点为根节点二叉树的左子树的最小节点
     * @param node
     * @return 返回改最小节点
     */
    public Node delTargetRightTreeMin(Node node) {
        Node target = node;
        while (target.getLeftNode() != null) {//找到最小节点
            target = target.getRightNode();
        }
        deleteNode(target);
        return target;
    }
}

//创建node节点
class Node {
    private int value;
    private Node leftNode;
    private Node rightNode;

    public Node(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public Node getLeftNode() {
        return leftNode;
    }

    public Node getRightNode() {
        return rightNode;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public void setLeftNode(Node leftNode) {
        this.leftNode = leftNode;
    }

    public void setRightNode(Node rightNode) {
        this.rightNode = rightNode;
    }

    /**
     * 当前节点的树的高度
     * @return
     */
    public int height() {
        //左子树的高度和右子树的高度的最大值
        return Math.max(leftNode == null?0:leftNode.height(),rightNode==null?0:rightNode.height())+1;
    }

    /**
     * 右子树的高度
     * @return
     */
    public int leftHeight() {
        if (leftNode == null) {
            return 0;
        } else {
            return leftNode.height();
        }
    }

    /**
     * 右子树的高度
     * @return
     */
    public int rightHeight() {
        if (rightNode == null) {
            return 0;
        } else {
            return rightNode.height();
        }
    }

    /**
     * 左旋转BST
     */
    private void leftRotate() {
        //创建一个新的节点 newNode (以4这个值创建)
        //,创建一个新的节点，值等于当前根节点的值
        Node newLeft = new Node(value);
        //把新节点的左子树设置了当前节点的左子树
        newLeft.leftNode=leftNode;
        //把新节点的右子树设置为当前节点的右子树的左子树
        newLeft.rightNode=rightNode.leftNode;
        //把当前节点的值换为右子节点的值
        value=rightNode.value;
        //把当前节点的右子树设置成右子树的右子树
        rightNode=rightNode.rightNode;
        //把当前节点的左子树设置为新节点
        leftNode=newLeft;
    }

    /**
     * 右旋转
     */
    public void rightRotate() {
        Node newNode = new Node(value);
        newNode.rightNode = rightNode;
        newNode.leftNode = leftNode.rightNode;
        value = leftNode.value;
        leftNode = leftNode.leftNode;
        rightNode = newNode;
    }

    /**
     * 递归的形式添加节点，要满足二叉排序树的要求
     * @param node
     */
    public void addNode(Node node) {
        if (node == null) {
            return;
        }
        //节点的值大于当前节点的值
        if (node.getValue() > this.value) {
            //当前节点的右子树为空直接挂上
            if (this.rightNode == null) {
                this.rightNode = node;
            } else {
                //否则递归
                this.rightNode.addNode(node);
            }
        } else {//把大于等于当前节点的挂到左子树
            if (this.leftNode == null) {
                this.leftNode = node;
            } else {
                this.leftNode.addNode(node);
            }
        }

        //添加节点的时候判断是否需要左旋转
        if (rightHeight()-leftHeight()>1) {
            //如果在左旋转的时候，当前节点的右子树的右子树的高度大于右子树的左子树的高度
            if (rightNode != null && rightNode.leftHeight() > rightNode.rightHeight()) {
                //先对当前节点的右子树进行左旋转
                rightNode.rightRotate();
                //然后对当前节点进行右旋转
                leftRotate();
            } else {
                //否则只对当前节点进行右旋转
                leftRotate();
            }
            return;
        }
        if (leftHeight() - rightHeight() > 1) {
            if (leftNode != null && leftNode.rightHeight() > leftNode.leftHeight()) {
                leftNode.leftRotate();
                rightRotate();
            } else {
                rightRotate();
            }
        }
    }

    /**
     * 中序遍历二叉树
     */
    public void infixOrder() {
        if (this.getLeftNode() != null) {
            this.getLeftNode().infixOrder();
        }
        //输出当前节点
        System.out.println(this.getValue());
        if (this.getRightNode() != null) {
            this.getRightNode().infixOrder();
        }
    }

    /**
     * 查找要删除的节点
     * @param node 要查找的节点
     * @return 如果找到返回该节点
     */
    public Node search(Node node) {
        if (node == null) {
            return null;
        }
        if (node.getValue() == this.value) {
            return this;
        } else if (node.getValue() < this.value) {//当前节点大于查找的节点，向左子树递归查找
            if (this.getLeftNode() == null) {
                return null;
            }
            return this.leftNode.search(node);
        } else {
            if (this.rightNode == null) {
                return null;
            }
            return this.rightNode.search(node);
        }
    }

    /**
     * 查找删除节点的父节
     * @param node
     * @return 返回当前节点的父节点
     */
    public Node searchParent(Node node) {
        Node parent = null;
        if (node == null) {
            return null;
        }
        if (this.value == node.value) {
            return parent;
        }
        parent = this;
        if (this.value > node.value) {
            if (this.leftNode == null) {
                return null;
            }
            return this.leftNode.searchParent(node);
        } else {
            if (this.rightNode == null) {
                return null;
            }
            return this.rightNode.searchParent(node);
        }
    }

    public Node searchParent2(Node node) {
        if ((this.getLeftNode() != null && this.getLeftNode().getValue() == node.getValue() ||
                this.getRightNode() != null && this.getRightNode().getValue() == node.getValue())) {
            return this;
        } else {
            if (this.getLeftNode() != null && node.getValue() <= this.getValue()) {
                return this.getLeftNode().searchParent2(node);
            } else if (this.getRightNode() != null && node.getValue() > this.getValue()) {
                return this.getRightNode().searchParent2(node);
            } else {
                return null;//没有找到父节点
            }
        }
    }
}

     

avl树的增删改查和BST树是一样的，只不过在BST的操作上加上旋转操作。

小小角色熊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解AVL树（平衡二叉树）
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
数据结构 —— 图解AVL树(平衡二叉树)
热门推荐
猎人在吃肉
07-28 3万+
文章目录1、AVL树(平衡二叉树)的定义1.1、平衡因子2、AVL树的作用：3、AVL树的基本操作3.1、插入—— 左左型的右旋：3.1.1、右旋的具体步骤：3.1.2、右旋的动画演示：3.1.3、右旋示例：3.2、插入——右右型的左旋：3.2.1、左旋的具体步骤：3.2.2、动画演示：3.2.3、左旋举例：3.3、插入——左右型的左右旋 ( 即先左后右)：3.3.1、左右旋的两次旋转步骤：3.3...
【数据结构】AVL树（平衡二叉树）
最新发布
liuty0125的博客
06-10 1189
AVL树是一个平衡的二叉搜索树，它的每个节点的左右子树高度差的绝对值不超过1，因此，哪怕最坏也只是查找高度次，保证了查询时高效的时间复杂度O(log_n)。 但是它的缺陷也很明显：如果我们要对AVL树做一些修改方面的操作时，它的性能就十分低了，因为在修改时我们还要维护它的绝对平衡，旋转的次数比较多，而且在删除时，最坏情况可能会更新到根节点。 所以，如果只是需要一种查询高效且有序的数据结构，且数据个数为静态（不改变），比较适合AVL树，但如果你需要经常修改的话，AVL树可能就不太适合了
AVL树（动图详解）
2021dragon的博客
12-02 2万+
AVL树（C++实现）
数据结构--AVL树（全）
weixin_48560325的博客
05-01 8882
目录 什么是AVL树？ AVL树的特点及形成原因 二叉搜索树基本概念 二叉搜索的特点 二叉搜索树的优点及缺点 改进的二叉搜索树——AVL树 AVL树的定义 AVL树的特点 结点的平衡因子balance 构建一个AVL树 构建一个AVL树的节点 什么是AVL树？ AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 AVL树的特点及形成原因 AVL树本质.
【数据结构】AVL树
weixin_74078718的博客
05-12 3087
AVL树的概念、定义、插入、旋转等内容。
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
AVL.rar_AVL树
09-21
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树，AV是两位发明者姓名的首字母。这种数据结构在进行插入和删除操作后能自动调整...
AVL.zip_AVL树
09-14
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树。这种数据结构的主要特点是每个节点的两个子树的高度差不超过1，确保了树的...
排序二叉树 AVL树 哈夫曼树增删改查Java实现
05-11
排序二叉树 AVL树 哈夫曼树增删改查Java实现
avl.rar_AVL树
09-19
AVL树是一种自平衡二叉查找树（Self-Balancing Binary Search Tree，简称SBT），由G. M. Adelson-Velsky和E. M. Landis在1962年提出，因此得名AVL树，其中AV代表两位发明者的名字首字母。这种数据结构在计算机科学中...
avl.rar_AVL树_树
09-23
AVL树是一种自平衡二叉查找树（Binary Search Tree，简称BST），由Georgy Adelson-Velsky和Emanuel Landis在1962年提出，因此得名AVL树，AVL是两位发明者名字的首字母缩写。在AVL树中，每个节点的两个子树的高度差...
AVL.rar_AVL树_avl
09-19
AVL树是一种自平衡二叉查找树（Binary Search Tree, BST），由Georgy Adelson-Velsky和Emanuel Landis于1962年提出，因此得名AVL树，其中AVL是两位发明者姓氏的首字母。这种数据结构在计算机科学中被广泛用于实现...
AVL树详解
Allence的博客
02-14 1万+
一、简介 AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。它是最先发明的自平衡二叉查找树，也被称为高度平衡树。 上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。 AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。 如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状..
AVL树（平衡二叉搜索树）
langk_的博客
09-03 3310
带你手撕AVL树，左单旋，右单旋，左右双旋，右左双旋
AVL树：平衡搜索树的优化策略
AVL树是一种自平衡的二叉搜索树，它是在1962年由G.M.Adelson-Velsky和E.M.Landis发明的，用于优化二叉搜索树的性能，特别是减少搜索时间。引入AVL树的主要目的是为了提高二叉搜索树的效率，确保树的高度保持在最优...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值