AVLT(平衡树)——基于二分树的 节点高度、平衡因子

最新推荐文章于 2023-09-17 09:23:32 发布
最新推荐文章于 2023-09-17 09:23:32 发布
阅读量1k 收藏 1
点赞数
分类专栏： 数据结构 文章标签： AVLT 平衡因子 平衡树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoxin0630/article/details/87872534
版权

平衡二叉树

对于任意一个节点，左子树和右字数的高度差不能为超过1

 

 

标注节点的高度（也可以直接看成多少层 如下就可以看到 总共就是5层）

叶子节点、对应的高度就是1、父节点就是最高的节点+1

计算平衡因子

叶子节点 空的就是左0 右0   0-0=0 叶子节点是0

左右两树的高度差就是因子、仔细看图

 

 

在以前的BST(二分树的基础下、略微修改)

private class Node{
        public K key;
        public V value;
        public Node left, right;
        public int height;//新添加元素高度

        public Node(K key, V value){
            this.key = key;
            this.value = value;
            left = null;
            right = null;
            height=1;//新添加
        }
    }

    private Node root;
    private int size;

    public AVLTree(){
        root = null;
        size = 0;
    }

    public int getSize(){
        return size;
    }

    public boolean isEmpty(){
        return size == 0;
    }

获取节点高度

//获取节点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);
    }

 

添加元素的更新高度

高度就是两个的子节点的最高+1

        // 更新height
        node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));

        // 计算平衡因子
        int balanceFactor = getBalanceFactor(node);
        if(Math.abs(balanceFactor) > 1)
            System.out.println("unbalanced : " + balanceFactor);

 // 向二分搜索树中添加新的元素(key, value)
    public void add(K key, V value){
        root = add(root, key, value);
    }

    // 向以node为根的二分搜索树中插入元素(key, value)，递归算法
    // 返回插入新节点后二分搜索树的根
    private Node add(Node node, K key, V value){

        if(node == null){
            size ++;
            return new Node(key, value);
        }

        if(key.compareTo(node.key) < 0)
            node.left = add(node.left, key, value);
        else if(key.compareTo(node.key) > 0)
            node.right = add(node.right, key, value);
        else // key.compareTo(node.key) == 0
            node.value = value;

        // 更新height
        node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));

        // 计算平衡因子
        int balanceFactor = getBalanceFactor(node);
        if(Math.abs(balanceFactor) > 1)
            System.out.println("unbalanced : " + balanceFactor);

        return node;
    }

 

 

总体代码

package com.binglian.AVLTree;
import java.util.ArrayList;

/**
 * 吧BST 略微修改
 * @author binglian
 *
 * @param <K>
 * @param <V>
 */
public class AVLTree<K extends Comparable<K>, V> {

    private class Node{
        public K key;
        public V value;
        public Node left, right;
        public int height;//新添加元素高度

        public Node(K key, V value){
            this.key = key;
            this.value = value;
            left = null;
            right = null;
            height=1;//新添加
        }
    }

    private Node root;
    private int size;

    public AVLTree(){
        root = null;
        size = 0;
    }

    public int getSize(){
        return size;
    }

    public boolean isEmpty(){
        return size == 0;
    }

    //获取节点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);
    }

    // 向二分搜索树中添加新的元素(key, value)
    public void add(K key, V value){
        root = add(root, key, value);
    }

    // 向以node为根的二分搜索树中插入元素(key, value)，递归算法
    // 返回插入新节点后二分搜索树的根
    private Node add(Node node, K key, V value){

        if(node == null){
            size ++;
            return new Node(key, value);
        }

        if(key.compareTo(node.key) < 0)
            node.left = add(node.left, key, value);
        else if(key.compareTo(node.key) > 0)
            node.right = add(node.right, key, value);
        else // key.compareTo(node.key) == 0
            node.value = value;

        // 更新height
        node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));

        // 计算平衡因子
        int balanceFactor = getBalanceFactor(node);
        if(Math.abs(balanceFactor) > 1)
            System.out.println("unbalanced : " + balanceFactor);

        return node;
    }

    // 返回以node为根节点的二分搜索树中，key所在的节点
    private Node getNode(Node node, K key){

        if(node == null)
            return null;

        if(key.equals(node.key))
            return node;
        else if(key.compareTo(node.key) < 0)
            return getNode(node.left, key);
        else // if(key.compareTo(node.key) > 0)
            return getNode(node.right, key);
    }

    public boolean contains(K key){
        return getNode(root, key) != null;
    }

    public V get(K key){

        Node node = getNode(root, key);
        return node == null ? null : node.value;
    }

    public void set(K key, V newValue){
        Node node = getNode(root, key);
        if(node == null)
            throw new IllegalArgumentException(key + " doesn't exist!");

        node.value = newValue;
    }

    // 返回以node为根的二分搜索树的最小值所在的节点
    private Node minimum(Node node){
        if(node.left == null)
            return node;
        return minimum(node.left);
    }

    // 删除掉以node为根的二分搜索树中的最小节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMin(Node node){

        if(node.left == null){
            Node rightNode = node.right;
            node.right = null;
            size --;
            return rightNode;
        }

        node.left = removeMin(node.left);
        return node;
    }

    // 从二分搜索树中删除键为key的节点
    public V remove(K key){

        Node node = getNode(root, key);
        if(node != null){
            root = remove(root, key);
            return node.value;
        }
        return null;
    }

    private Node remove(Node node, K key){

        if( node == null )
            return null;

        if( key.compareTo(node.key) < 0 ){
            node.left = remove(node.left , key);
            return node;
        }
        else if(key.compareTo(node.key) > 0 ){
            node.right = remove(node.right, key);
            return node;
        }
        else{   // key.compareTo(node.key) == 0

            // 待删除节点左子树为空的情况
            if(node.left == null){
                Node rightNode = node.right;
                node.right = null;
                size --;
                return rightNode;
            }

            // 待删除节点右子树为空的情况
            if(node.right == null){
                Node leftNode = node.left;
                node.left = null;
                size --;
                return leftNode;
            }

            // 待删除节点左右子树均不为空的情况

            // 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
            // 用这个节点顶替待删除节点的位置
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            successor.left = node.left;

            node.left = node.right = null;

            return successor;
        }
    }

    public static void main(String[] args){

        System.out.println("Pride and Prejudice");

        ArrayList<String> words = new ArrayList<>();
        if(FileOperation.readFile("pride-and-prejudice.txt", words)) {
            System.out.println("Total words: " + words.size());

            AVLTree<String, Integer> map = new AVLTree<>();
            for (String word : words) {
                if (map.contains(word))
                    map.set(word, map.get(word) + 1);
                else
                    map.add(word, 1);
            }

            System.out.println("Total different words: " + map.getSize());
            System.out.println("Frequency of PRIDE: " + map.get("pride"));
            System.out.println("Frequency of PREJUDICE: " + map.get("prejudice"));
        }

        System.out.println();
    }
}

 

冰怜
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之平衡二叉树的平衡因子BF 的计算
followMyInclinations的专栏
12-29 1万+
在书上看了平衡二叉树的代码后，发现前人的智慧真是无限。但是因为一次性给出的最完美的代码让人有时候看不太懂... 后来经过仔细推敲，才慢慢发现了其中的奥秘。一开始并不知道关于平衡二叉树的平衡因子BF是怎么修改的，后来才发现关于平衡二叉树的最重要的一句话：在构建平衡二叉树的过程中，每当插入一个结点时，先检查是否因插入而破坏了树的平衡性，若是，则找出最小不平衡子树，在保持二叉排序树特性的前提下，调整关
平衡二叉树
DramaLifes的博客
07-29 1059
满二叉树一定是一颗平衡二叉树 平衡二叉树：对于任意一个节点，左子树和右子树的高度差不能超过1 平衡二叉树的高度和节点数量之间的关系也是O（logn）的 节点的高度等于左右子树中最高的节点的高度 加一 平衡因子：左右子树的高度差（较大的减较小的）或者左右 子树高度差的绝对值 如果平衡因子大于1，则不是一棵平衡二叉树，不大于1则是一颗平衡二叉树 我们在原来的二分...
计算二叉树中每个节点的平衡因子
qq_45065778的博客
11-10 5115
思想：递归的计算每个节点的左子树与右子树的深度，然后左子树深度-右子树深度即为平衡因子 标题
数据结构与算法——平衡二叉树（AVL Tree）
qq_25065595的博客
08-20 254
数据结构与算法——平衡二叉树（AVL Tree） 构建一个二叉排序树时，如果构建序列是完全有序的，则会出现这样的情况： 显然这种情况会使得二叉搜索树退化成链表。当出现这样的情况，二叉排序树的查找也就退化成了线性查找，所以我们需要合理调整二叉排序树的形态，使得树上的每个结点都尽量有两个子结点，这样整个二叉树的高度就会大约在log(n)log(n)左右，其中nn为结点个数。 基本性质 ​AVL树也称为平衡二叉树，是一种自平衡的二叉排序树，本质上仍然是一颗二叉排序树，只是增加了“平衡”的...
算法经典|二分查找详解
linovce的博客
09-18 3101
查询算法是非常重要的算法之一，即便不从事算法相关岗位，在CRUD的开发岗中，查询也是常见的业务操作。通常我们是从头到尾查询一个顺序表(数组、链表等)得到我们的结果，这种方式的时间复杂度为O(n)，但针对一些特殊的数据，可以采取更加高效的方式查询。
平衡树——自平衡二叉树(Balanced Tree - AVL Tree)
UoM_XiaoShuaiShuai的博客
06-10 1590
平衡树——自平衡二叉树(Balanced Tree - AVL Tree)定义(Definition) An AVL tree is a self-balancing binary search tree. It was named after its two inventors: Georgy Adelson-Velsky and Evgenii Landis. Recall that we d
平衡二叉树(AVL树).docx
12-07
平衡因子是衡量树是否平衡的重要指标，定义为节点的左子树高度减去右子树高度。在不同的资料中，平衡因子的定义可能存在差异，有的定义为左高减右高，有的反之。但无论哪种定义，只要平衡因子的绝对值大于1，就表明...
AVL树 C++ 实现
09-20
以下是一个基本的AVL树节点定义： ```cpp template <typename T> struct AVLNode { T data; int height; AVLNode<T>* left; AVLNode<T>* right; }; ``` AVL树的核心操作包括旋转、插入和删除，下面简要介绍...
二叉排序树与平衡二叉树的实现
12-26
　②在最好情况下，二叉排序树在生成的过程中，树的形态比较匀称，最终得到的是一棵形态与二分查找的判定树相似的二叉排序树，此时它的平均查找长度大约是lgn。　③插入、删除和查找算法的时间复杂度均为O(lgn)。 ...
AVL树的完整实现（含比较器，Java语言描述）
12-22
平衡因子是左子树高度减去右子树高度的值，用来判断是否需要旋转。例如： ```java public class AvlNode<T extends Comparable> { T element; AvlNode left, right; int height; public AvlNode(T element) { ...
数据结构与算法设计课程设计-二叉排序树与平衡二叉树.docx
06-28
1. **AVL树的平衡因子**：每个节点的平衡因子是其左子树高度减去右子树高度，平衡因子±1表示平衡，±2表示不平衡。 2. **中序输出**：AVL树的中序遍历同样能得到有序序列。 3. **插入元素**：在AVL树中插入新元素...
AVL树平衡因子详解
热门推荐
Travelerwz的博客
08-11 2万+
AVL树就是平衡二叉树，左子树和右子树的高度之差绝对值不超过1。 而且规定，平衡二叉树的每个节点的平衡因子只能是-1 ，1 ，0； 按照公式   平衡因子 = 右子树的高度 - 左子树的高度 -1 ： 表示左子树比右子树高 1  : 表示右子树比左子树高 0 ： 表示左子树和右子树等高 但是很多人都知道公式，但却有时候不知道怎么去看一个平衡二叉树。 接下来我为大家详
数据结构——AVL树
stromSLR的博客
02-27 1328
AVL算法 前言 这篇文章主要是基于BST算法的衍生版本，因为在某些情况下，BST算法的时间复杂度会退化成O(n),所以才有了这个完全平衡的AVL算法，会通过平衡因子维护二叉搜索树的平衡，保证其查找时的时间复杂度为O(log2(n))，但是也有缺陷。 一、AVL算法的性质 1.左右子树高度差（平衡因子）的绝对值不超过1 （1）高度差——平衡因子 每个节点都有自己的平衡因子，当平衡因子大于1时，我们就需要进行调整，使其小于等于1 （2） 这里，一般我们默认平衡因子的大小是右树减左树 例如：右数高度为2，左树高
二叉树结点深度及平衡因子计算算法
weixin_43213382的博客
05-25 5743
从下往上开始计算每个结点的深度及平衡因子。 #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 typedef int Status; typedef struct Node { int data; int bf; int depth; struct N...
平衡二叉树平衡因子怎么计算_平衡二叉树（AVL Tree）旋转机制分析
weixin_39998998的博客
11-24 2062
平衡二叉树（AVL Tree）概述AVL树是以二分搜索树（BST）为底层数据结构而实现的，其特性是需要维护AVL的|平衡因子| <= 1 平衡因子 对于一个父节点的左右子树高度差的绝对值需要 <= 1AVL最复杂的操作在于add()和remove()两个方法需要维护AVL的平衡二叉树特性，细节在下面展开节点类由于需要知道AVL一个节点的高度，因此需要在BST的内部类Node中新维护一个...
「leetcode」110.平衡二叉树
代码随想录
10-08 443
和求最大深度一个套路？
平衡二叉树平衡因子怎么计算_面试官让我手写一个平衡二叉树，我当时就笑了...
weixin_39663593的博客
11-28 629
平衡二叉树对于初学者一直是一个比较复杂的知识点，因为其里面涉及到了大量的旋转操作。把大量的同学都给转晕了。这篇文章最主要的特点就是通过动画的形式演示。确保大家都能看懂。最后是手写一个平衡二叉树。一、概念平衡二叉树是外国的两个大爷发明的。一开始发明的是二叉查找树。后来觉得不给力演化成了平衡二叉树。那什么是二叉查找树呢？我们给出一张图来看看：看到这张图我们就会发现如下的特征。从每个节点出发，左边的节点...
数据结构：平衡二叉树
最新发布
梁辰兴的博客
09-17 427
平衡二叉树（Balanced Binary Tree）是一种特殊的二叉树，它满足任意一个节点的左子树和右子树的高度差不超过1。平衡二叉树的主要优势在于其能够保持较低的树高，从而在插入、删除和查找操作中保持较好的性能。简介平衡二叉树是一种自我平衡的二叉搜索树，它的左子树和右子树的高度差不超过1。平衡二叉树的基本操作包括插入、删除和查找，这些操作的时间复杂度均为O(log n)，其中n为树中节点的数量。平衡二叉树的主要应用场景包括计算机科学、数据结构和算法等领域。图示50/ \30 70。
AVL树：平衡搜索树的优化策略
如果平衡因子超过1或-1，就需要通过特定的旋转操作来重新平衡树，这些旋转包括： 1. 单向右旋（LL）：当插入导致父节点*a的左子树高度比右子树高2时，需要进行一次右旋，将左子树的左子树提升到父节点的位置。 2. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值