AVL平衡二叉树原理与代码实现过程详解

最新推荐文章于 2022-05-22 21:11:30 发布
最新推荐文章于 2022-05-22 21:11:30 发布
阅读量287 收藏 2
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 二叉树 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzh824359508/article/details/115301808
版权

AVL平衡二叉树

什么时平衡二叉树

平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

//定义一颗平衡二叉树的节点
template <class T>
struct AVLtreeNode{
	T data;
	AVLtreeNode<T>* lchild, * rchild;
	AVLtreeNode(T x){
		data=x;
		lchild=NULL;
		rchild=NULL;
	}
	AVLtreeNode(AVLtreeNode* n) { 
		data=n->data;
		lchild=n->lchild;
		rchild=n->rchild;
	}
};

二叉树的高度

注意区分二叉树的深度和高度。

  • 深度是从上到下计算
  • 高度是从下到上计算

int height(AVLtreeNode<T>* node){
	if (node == NULL)
		return 0;
	return std::max(height(node->lchild), height(node->rchild)) + 1;
}

平衡因子

  • 某结点的左子树与右子树的高度(深度)差即为该结点的平衡因子（BF,Balance Factor）。平衡二叉树上所有结点的平衡因子只可能是 -1，0 或 1。如果某一结点的平衡因子绝对值大于1则说明此树不是平衡二叉树。为了方便计算每一结点的平衡因子我们可以为每个节点赋予height这一属性，表示此节点的高度。
int balance_fector(AVLtreeNode<T>* node){
	if (node == NULL)
		return 0;
	return height(node->lchild) - height(node->rchild);
}

四种旋转方式

  1. 右旋
  • 设不平衡节点为根节点（20），其左节点（15）拿出当新根节点，左节点（15）的右节点给根节点（20）做其新左节点，左节点的右节点为新根节点。

在这里插入图片描述
在这里插入图片描述

AVLtreeNode<T>* RightMove(AVLtreeNode<T>* node){
	AVLtreeNode<T>* left = node->lchild;
	node->lchild = left->rchild;
	left->rchild = node;
	return left;
}
  1. 左旋
  • 设不平衡节点为根节点（10），其右节点（20）拿出当新根节点，右节点（20）的左节点给根节点（10）做其新右节点，右节点的左节点为新根节点。

在这里插入图片描述

在这里插入图片描述

AVLtreeNode<T>* LeftMove(AVLtreeNode<T>* node){
	AVLtreeNode<T>* right = node->rchild;
	node->lchild = right->lchild;
	right->lchild = node;
	return right;
}
  1. 左右旋
  • 先对不平衡节点的左节点做一次左旋，旋转之后变为情况一，之后再对不平衡节点做一次右旋

在这里插入图片描述
在这里插入图片描述

AVLtreeNode<T>* LeftRightMove(AVLtreeNode<T>* node){
	node->lchild = LeftMove(node->lchild);
	return RightMove(node);
}
  1. 右左旋
  • 先对不平衡节点的右节点做一次右旋，旋转之后变为情况二，之后再对不平衡节点做一次左旋

在这里插入图片描述
在这里插入图片描述

AVLtreeNode<T>* RightLeftMove(AVLtreeNode<T>* node){
	node->rchild = RightMove(node->rchild);
	return LeftMove(node);
}

判断何时用何种旋转

  • 当一个节点的左右子树高度之差大于1或小于-1时，该节点需要进行平衡旋转操作
  1. 平衡因子为2时，说明左子树高度比右子树高2，再次判断其左节点的平衡因子，若大于0就右旋，小于0就要左右旋。
  2. 平衡因子为-2时，说明右子树高度比左子树高2，再次判断其右节点的平衡因子，若小于0就左旋，大于0就要右左旋。

下面展示平衡因子为2的两种情况，平衡因子为-2同理。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

AVLtreeNode<T>* rebalance(AVLtreeNode<T>* node){
	int fector = balance_fector(node);
	if (fector == 2)//平衡因子为2肯定需要一步左旋或者先左旋再右旋{
		if (balance_fector(node->lchild) > 0)
			node = RightMove(node);
		else
			node = LeftRightMove(node);
	}
	if (fector == -2){//平衡因子为2肯定需要一步右旋或者先右旋再左旋
		if (balance_fector(node->rchild) < 0)
			node = LeftMove(node);
		else
			node = RightLeftMove(node);
	}
	return node;
}

AVL节点删除

AVLtreeNode<T>* remove(AVLtreeNode<T>* node, const T& val){
		if (node == NULL) return node;
		if (val < node->data){
			node->lchild = remove(node->lchild, val);
		}
		else if (val > node->data){
			node->rchild = remove(node->rchild, val);
		}
		else{
			if (node->lchild ==NULL){
				AVLtreeNode<T>* del = node;
				node = node->rchild;
				delete del;
			}
			else if (node->rchild == nullptr){
				AVLtreeNode<T>* del = node;
				node = node->lchild;
				delete del;
			}
			else{
				AVLtreeNode<T>* successor = new AVLtreeNode<T>(minimum(node->rchild));
				node->rchild = remove(node->rchild, successor->data);
				successor->lchild = node->lchild;
				successor->rchild = node->rchild;
				delete node;
				node = successor;
			}
		}
		return rebalance(node);
	}

AVL完整代码实现流程

#include<iostream>
#include <algorithm>
using namespace std;

template <class T>
struct AVLtreeNode
{
	T data;
	AVLtreeNode<T>* lchild, * rchild;
	AVLtreeNode(T x)
	{

		data=x;
		lchild=NULL;
		rchild=NULL;
	}
	AVLtreeNode(AVLtreeNode* n) 
	{ 
		data=n->data;
		lchild=n->lchild;
		rchild=n->rchild;
	}

};
template <class T>
class AVLTree
{
public:
	AVLTree()
	{
		root=NULL;
	}
	~AVLTree()
	{
		destory(root);
	}
	void destory(AVLtreeNode<T>* node)
	{
		if (node != NULL)
		{
			destory(node->lchild);
			destory(node->rchild);
			delete node;
		}
	}
    int height(AVLtreeNode<T>* node)
	{
		if (node == NULL)
			return 0;
		return std::max(height(node->lchild), height(node->rchild)) + 1;
	}
	int balance_fector(AVLtreeNode<T>* node)
	{
		if (node == NULL)
			return 0;
		return height(node->lchild) - height(node->rchild);
	}
	AVLtreeNode<T>* RightMove(AVLtreeNode<T>* node)
	{
		AVLtreeNode<T>* left = node->lchild;
		node->lchild = left->rchild;
		left->rchild = node;
		return left;
	}
	AVLtreeNode<T>* LeftMove(AVLtreeNode<T>* node)
	{
		AVLtreeNode<T>* right = node->rchild;
		node->lchild = right->lchild;
		right->lchild = node;
		return right;
	}
	AVLtreeNode<T>* LeftRightMove(AVLtreeNode<T>* node)
	{
		node->lchild = LeftMove(node->lchild);
		return RightMove(node);
	}
	AVLtreeNode<T>* RightLeftMove(AVLtreeNode<T>* node)
	{
		node->rchild = RightMove(node->rchild);
		return LeftMove(node);
	}
	AVLtreeNode<T>* insert(AVLtreeNode<T>* node, const T& val)
	{
		if (node == NULL)
			return new AVLtreeNode<T>(val);
		if (val == node->data)
			return node;
		if (val < node->data)
			node->lchild = insert(node->lchild, val);
		else
			node->rchild = insert(node->rchild, val);
		return rebalance(node);
	}
	AVLtreeNode<T>* rebalance(AVLtreeNode<T>* node)
	{
		int fector = balance_fector(node);
		if (fector == 2)//平衡因子为2肯定需要一步左旋或者先左旋再右旋
		{
			if (balance_fector(node->lchild) > 0)
				node = RightMove(node);
			else
				node = LeftRightMove(node);
		}
		if (fector == -2)//平衡因子为2肯定需要一步右旋或者先右旋再左旋
		{
			if (balance_fector(node->rchild) < 0)
				node = LeftMove(node);
			else
				node = RightLeftMove(node);
		}
		return node;
	}
	AVLtreeNode<T>* remove(AVLtreeNode<T>* node, const T& val)
	{
		if (node == NULL) return node;
		if (val < node->data)
		{
			node->lchild = remove(node->lchild, val);
		}
		else if (val > node->data)
		{
			node->rchild = remove(node->rchild, val);
		}
		else
		{
			if (node->lchild ==NULL)
			{
				AVLtreeNode<T>* del = node;
				node = node->rchild;
				delete del;
			}
			else if (node->rchild == nullptr)
			{
				AVLtreeNode<T>* del = node;
				node = node->lchild;
				delete del;
			}
			else
			{
				AVLtreeNode<T>* successor = new AVLtreeNode<T>(minimum(node->rchild));
				node->rchild = remove(node->rchild, successor->data);
				successor->lchild = node->lchild;
				successor->rchild = node->rchild;
				delete node;
				node = successor;
			}
		}
		return rebalance(node);
	}
	void insert(const T& val)
	{
		root = insert(root, val);
	}
	void remove(const T& val)
	{
		root = remove(root, val);
	}
	AVLtreeNode<T>* get_root()
	{
		return root;
	}
	AVLtreeNode<T>* minimum(AVLtreeNode<T>* node)
	{
		while (node->lchild)
		{
			node = node->lchild;
		}
		return node;
	}
	void output(AVLtreeNode<T>* p)
	{
		if (p != NULL)
		{
			output(p->lchild);
			cout << p->data << " ";
			output(p->rchild);
		}
	}
private:
	AVLtreeNode<T>* root;
};
int main()
{
	AVLTree<int> a;
	a.insert(30);
	a.insert(5);
	a.insert(40);
	a.insert(35);
	a.output(a.get_root());
	cout << endl;
	a.insert(32);
	a.output(a.get_root());
	cout << endl;
	a.remove(30);
	a.output(a.get_root());
	return 0;
}

验证二叉搜索树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    int tra=INT_MIN;
public:
    bool isValidBST(TreeNode* root) {
        if(!root) return true;
        bool left=isValidBST(root->left);
        if(root->val>tra){
            tra=root->val;
        }
        else
            return false;
        bool right=isValidBST(root->right);
        return left&&right;
    }
};

二叉搜索树最小差值

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    TreeNode* pre=nullptr;
    int minnum=INT_MAX;
    void traversal(TreeNode* node){
        if(!node) return;
        traversal(node->left);
        if(pre){
            minnum=min(minnum,node->val-pre->val);
        }
        pre=node;
        traversal(node->right);
    }
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return minnum;
    }
};

二叉搜索树的众数

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    int cnt=1;
    int maxcnt=1;
    TreeNode* pre=nullptr;
    vector<int> res;
    void traversal(TreeNode* cur){
        if(!cur) return;
        traversal(cur->left);
        if(pre){
            if(pre->val==cur->val){
                cnt++;
            }
            else cnt=1;
        }
        pre=cur;
        if(cnt==maxcnt){
            res.push_back(cur->val);
        }
        if(cnt>maxcnt){
            res.clear();
            res.push_back(cur->val);
            maxcnt=cnt;
        }
        traversal(cur->right);
    }
public:
    vector<int> findMode(TreeNode* root) {
        traversal(root);
        return res;
    }
};

二叉搜索树的插入

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if (root == NULL) {
            TreeNode* node = new TreeNode(val);
            return node;
        }
        if (root->val > val) root->left = insertIntoBST(root->left, val);
        if (root->val < val) root->right = insertIntoBST(root->right, val);
        return root;
    }
};

二叉搜索树的删除

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == nullptr) return root;
        if (root->val > key) root->left = deleteNode(root->left, key);
        if (root->val < key) root->right = deleteNode(root->right, key); // 第一种情况：没找到删除的节点，遍历到空节点直接返回了
        if (root->val == key) {
            // 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
            // 第三种情况：其左孩子为空，右孩子不为空，删除节点，右孩子补位 ，返回右孩子为根节点
            if (root->left == nullptr){
                TreeNode* del=root;
                root=root->right;
                delete(del);
            } 
            // 第四种情况：其右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
            else if (root->right == nullptr){
                TreeNode* del=root;
                root=root->right;
                delete(del);
            } 
            // 第五种情况：左右孩子节点都不为空，则将删除节点的左子树放到删除节点的右子树的最左面节点的左孩子的位置
            // 并返回删除节点右孩子为新的根节点。
            else {
                TreeNode* cur = root->right; // 找右子树最左面的节点
                while(cur->left != nullptr) {
                    cur = cur->left;
                }
                cur->left = root->left; // 把要删除的节点（root）左子树放在cur的左孩子的位置
                TreeNode* tmp = root;   // 把root节点保存一下，下面来删除
                root = root->right;     // 返回旧root的右孩子作为新root
                delete tmp;             // 释放节点内存（这里不写也可以，但C++最好手动释放一下吧）
                return root;
            }
        }
        
        return root;
    }
};
VioletEvergarden丶
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构之---C语言实现平衡二叉树（AVL树）
杨鑫newlife的专栏
09-02 7562
数据结构之---C语言实现平衡二叉树（AVL树）
C语言实现AVL-平衡二叉树
silence2015的专栏
03-23 9761
前言在学习了二叉搜索树后，我们可以通过二叉搜索树实现结点有序存储。 我们在删除结点的时候，采用的是该结点右子树中最小结点代替他，探后再删除最小的那个结点，这种做法虽然保证了二叉树的有序性，但是久而久之使二叉树越来越不平衡，右边结点越来越少。像这样 或许在右子树中选择最小和左子树中选择最大轮换地使用可以稍微解决一下这种不平衡，但是在这里我们介绍一种AVL树来保证二叉查找树的平衡，AVL树得名于它的
平衡二叉树（AVL 树）：概念、实现原理和算法代码
16A086的博客
06-18 883
文章目录引入定义实现原理概述单旋转双旋转实现算法单旋转双旋转插入操作参考资料 引入 上一篇中已经介绍了二叉搜索树（BST），在二叉搜索树的复杂度分析中，我们提到，二叉搜索树的算法复杂度与其拓扑结构（具体来说是其树的深度）有关。当 BST 最为「平衡」时，查找、删除、插入的算法为 O(log⁡n)O(\log{n})O(logn)，而最不平衡情况下，算法复杂度为 O(n)O(n)O(n)。 当节点数 nnn 增长时，O(log⁡n)O(\log{n})O(logn) 的算法相对于 O(n)O(n)O(n) 的
AVL树（平衡二叉树）
m0_50987639的博客
05-22 104
AVL
数据结构 -- AVL平衡二叉树Java代码实现
zhangdm的博客
11-24 397
平衡二叉树
平衡二叉树详解及java代码的实现
01-19
平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树（递归定义）的二叉排序树。...
C语言 数据结构平衡二叉树实例详解
08-30
C语言 数据结构平衡二叉树实例详解 以下是对C语言数据结构平衡二叉树实例详解的知识点总结： 1. 平衡二叉树的定义：平衡二叉树是一种特殊的二叉树，它的左子树和右子树的高度差不能超过1，使得树的高度尽可能的小...
c/c++二叉树详解，作业，学习参考
12-04
学习数据结构的C++源码，包含AVL树、Treap、多个有序链表合并、二叉查找树、二项堆、红黑树、伸展树、跳表、栈与队列相互模拟以及最小(大)值求解，可做参考学习
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
数据结构实验代码 二叉树
05-14
在实验过程中，学生可能还会涉及其他高级主题，如平衡二叉树（如AVL树和红黑树），它们通过自动调整保持树的平衡，从而保证搜索操作的时间复杂度为O(log n)。此外，二叉堆（如最大堆和最小堆）在优先队列和排序算法...
avltree算法.rar_avl_avl tree
09-21
数据结构avltr
平衡二叉树（AVL）的实现，附可运行C语言代码
ringrang的专栏
08-31 1302
最近几月一直在自学C语言和数据结构，先是写了排序二叉树，觉得平衡二叉树作为一个经典数据结构，有必要实现一下。 网上看了些资料，在AVL和红黑树之间考虑，最后个人还是倾向于AVL。 不同于标准AVL的是，笔者没有使用平衡因子，直接根据左右孩子的高度差值判断是否平衡。整个平衡二叉树是在普通二叉查找树的基础上修改得到的，对于学习数据结构的同学来说，这样逐步提高难度，写起来挑战性没那么大。
AVL平衡二叉树图+代码详解
氵青-风的博客
11-29 1053
平衡二叉树的定义：是一种二叉排序树（可以是空树），其中每一个节点的左右两个子树的高度差的绝对值不超过1。 注意：二叉排序树不一定是平衡二叉树！平衡因子的概念： 二叉树上节点的左子树深度减去右子树深度的值称为平衡因子BF（Balance Factor）例如： 下面这棵树就不是平衡二叉树，因为58、88节点都不符合平衡二叉树的定义，BF分别为2，-2下面这棵树也不是平衡二叉树，因为58节点
java平衡二叉树(AVL)代码
m0_50262736的博客
02-18 400
package avl; public class AVLTreeDemo { public static void main(String[] args) { // TODO Auto-generated method stub // int arr[]= {4,3,6,5,7,8}; //int arr[] = { 10, 12, 8, 9, 7, 6 }; int []arr= {10,11,7,6,8,9}; ...
AVL树（平衡二叉树）的底层原理以及实现
荣耀与梦想来日方长
03-11 1221
前言 Wiki:在计算机科学中，AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度都是{\displaystyle O(\log {n})} 。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。AVL 树得名于它的发明者G. M. Adelson-Velsky和Evgenii Landis，他们在1962年的论文《An algorithm for the org...
AVL算法
rave..juine
07-05 1337
#include #include #define EH 0 #define LH 1 #define RH -1 typedef struct Bitree { int data; int bf;
一步一步写平衡二叉树（AVL树）
weixin_30588907的博客
08-20 557
一步一步写平衡二叉树（AVL树） 作者：C小加 更新时间：2012-8-20 　　平衡二叉树（Balanced Binary Tree）是二叉查找树的一个进化体，也是第一个引入平衡概念的二叉树。1962年，G.M. Adelson-Velsky 和 E.M. Landis发明了这棵树，所以它又叫AVL树。平衡二叉树要求对于每一个节点来说，它的左右子树的高度之差不能超过1，如果插入或者删除一个节...
平衡二叉树(AVL树)的平衡原理以及插入,删除操作
热门推荐
weixin_36888577的博客
02-13 3万+
文章目录AVL树的定义AVL树不平衡的情况左子树的左子树插入结点 (左左)右子树的右子树插入节点左子树的右子树插入节点右子树的左子树插入节点删除结点插入节点更复杂的情况所有代码测试结果 AVL树的定义 平衡因子 : 树中某结点其左子树的高度和右子树的高度之差 AVL树中的任意一个结点, 其平衡因子的绝对值小于2 AVL树是一种特殊的二叉搜索树 (BST树), 相对于数据极端情况下, 二叉搜索树会...
AVL树算法介绍与总结
qq_37329281的博客
02-22 462
  在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文 "An algorithm fo...
平衡二叉树c语言实现代码
最新发布
12-13
以下是一个简单的C语言实现平衡二叉树的代码，其中包括了对于四种不平衡情况的处理和递归添加新数据的方法： ```c #include #include typedef struct node { int data; struct node *left; struct node *...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

VioletEvergarden丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值