算法入门＜三＞：升级平衡二叉搜索树之AVL 树

news2024/11/17 23:59:14

1、前言

二叉搜索树在多次插入和删除操作后，可能退化为链表。在这种情况下，所有操作的时间复杂度将从 O(logn)劣化为 O(n)。如图所示，经过两次删除节点操作，这棵二叉搜索树便会退化为链表; 完美二叉树中插入两个节点后，树将严重向左倾斜，查找操作的时间复杂度也随之劣化。因此产生了AVL树来解决这个问题。
在这里插入图片描述

2、AVL 树

1962 年 G. M. Adelson-Velsky 和 E. M. Landis 在论文“An algorithm for the organization of information”中提出了 AVL 树。论文中详细描述了一系列操作，确保在持续添加和删除节点后，AVL 树不会退化，从而使得各种操作的时间复杂度保持在
O(logn) 级别。换句话说，在需要频繁进行增删查改操作的场景中，AVL 树能始终保持高效的数据操作性能，具有很好的应用价值。

AVL 树既是二叉搜索树，也是平衡二叉树，同时满足这两类二叉树的所有性质，因此是一种平衡二叉搜索树（balanced binary search tree）。

2.1 二叉树的常用术语

根节点（root node）：位于二叉树顶层的节点，没有父节点。
叶节点（leaf node）：没有子节点的节点，其两个指针均指向 None 。
边（edge）：连接两个节点的线段，即节点引用（指针）。
节点所在的层（level）：从顶至底递增，根节点所在层为 1 。
节点的度（degree）：节点的子节点的数量。在二叉树中，度的取值范围是 0、1、2 。
二叉树的高度（height）：从根节点到最远叶节点所经过的边的数量。
节点的深度（depth）：从根节点到该节点所经过的边的数量。
节点的高度（height）：从距离该节点最远的叶节点到该节点所经过的边的数量。

在这里插入图片描述

2.2 节点高度

“节点高度”是指从该节点到它的最远叶节点的距离，即所经过的“边”的数量。需要特别注意的是，叶节点的高度为
0，而空节点的高度为 -1。

2.3 节点平衡因子

节点的平衡因子（balance factor）定义为节点左子树的高度减去右子树的高度，同时规定空节点的平衡因子为 0。

2.4 AVL树旋转

AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中序遍历序列的前提下，使失衡节点重新恢复平衡。换句话说，旋转操作既能保持“二叉搜索树”的性质，也能使树重新变为“平衡二叉树”。我们将平衡因子绝对值的节点称为“失衡节点”。

根据节点失衡情况的不同，旋转操作分为四种：右旋、左旋、先右旋后左旋、先左旋后右旋。四种旋转情况的选择条件可以依据下表来进行判断。
在这里插入图片描述

3、AVL树构建

#pragma once

#include<iostream>
#include<algorithm>
#include<string>

/* AVL 树节点类 */
class TreeNode 
{
public:
	int val = 0;        // 节点值
	int height = 0;     // 节点高度
	TreeNode* left{};   // 左子节点
	TreeNode* right{};  // 右子节点
	TreeNode() = default;
	explicit TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

#include "pch.h"
#include "avl_tree.h"


/* 获取节点高度 */
int height(TreeNode* node)
{
	// 空节点高度为 -1 ，叶节点高度为 0
	return node == nullptr ? -1 : node->height;
}

/* 更新节点高度 */
void updateHeight(TreeNode* node)
{
	// 节点高度等于最高子树高度 + 1
	node->height = std::max(height(node->left), height(node->right)) + 1;
}

/* 获取平衡因子 */
int balanceFactor(TreeNode* node)
{
	// 空节点平衡因子为 0
	if (node == nullptr)
		return 0;
	// 节点平衡因子 = 左子树高度 - 右子树高度
	return height(node->left) - height(node->right);
}

/* 右旋操作 */
TreeNode* rightRotate(TreeNode* node)
{
	TreeNode* child = node->left;
	TreeNode* grandChild = child->right;
	// 以 child 为原点，将 node 向右旋转
	child->right = node;
	node->left = grandChild;
	// 更新节点高度
	updateHeight(node);
	updateHeight(child);
	// 返回旋转后子树的根节点
	return child;
}

/* 左旋操作 */
TreeNode* leftRotate(TreeNode* node)
{
	TreeNode* child = node->right;
	TreeNode* grandChild = child->left;
	// 以 child 为原点，将 node 向左旋转
	child->left = node;
	node->right = grandChild;
	// 更新节点高度
	updateHeight(node);
	updateHeight(child);
	// 返回旋转后子树的根节点
	return child;
}

/* 执行旋转操作，使该子树重新恢复平衡 */
TreeNode* rotate(TreeNode* node)
{
	// 获取节点 node 的平衡因子
	int _balanceFactor = balanceFactor(node);
	// 左偏树
	if (_balanceFactor > 1)
	{
		if (balanceFactor(node->left) >= 0)
		{
			// 右旋
			return rightRotate(node);
		}
		else
		{
			// 先左旋后右旋
			node->left = leftRotate(node->left);
			return rightRotate(node);
		}
	}
	// 右偏树
	if (_balanceFactor < -1)
	{
		if (balanceFactor(node->right) <= 0)
		{
			// 左旋
			return leftRotate(node);
		}
		else
		{
			// 先右旋后左旋
			node->right = rightRotate(node->right);
			return leftRotate(node);
		}
	}

	// 平衡树，无须旋转，直接返回
	return node;
}

/* 递归插入节点（辅助方法） */
TreeNode* insertHelper(TreeNode* node, int val)
{
	if (node == nullptr)
		return new TreeNode(val);
	/* 1. 查找插入位置并插入节点 */
	if (val < node->val)
		node->left = insertHelper(node->left, val);
	else if (val > node->val)
		node->right = insertHelper(node->right, val);
	else
		return node;    // 重复节点不插入，直接返回
	updateHeight(node); // 更新节点高度
	/* 2. 执行旋转操作，使该子树重新恢复平衡 */
	node = rotate(node);
	// 返回子树的根节点
	return node;
}

/* 插入节点 */
void insert(TreeNode* root, int val)
{
	root = insertHelper(root, val);
}

/* 递归删除节点（辅助方法） */
TreeNode* removeHelper(TreeNode* node, int val)
{
	if (node == nullptr)
	{
		return nullptr;
	}

	/* 1. 查找节点并删除 */
	if (val < node->val)
	{
		node->left = removeHelper(node->left, val);
	}
	else if (val > node->val)
	{
		node->right = removeHelper(node->right, val);
	}
	else
	{
		if (node->left == nullptr || node->right == nullptr)
		{
			TreeNode* child = node->left != nullptr ? node->left : node->right;
			// 子节点数量 = 0 ，直接删除 node 并返回
			if (child == nullptr) {
				delete node;
				return nullptr;
			}
			// 子节点数量 = 1 ，直接删除 node
			else {
				delete node;
				node = child;
			}
		}
		else
		{
			// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
			TreeNode* temp = node->right;
			while (temp->left != nullptr)
			{
				temp = temp->left;
			}

			int tempVal = temp->val;
			node->right = removeHelper(node->right, temp->val);
			node->val = tempVal;
		}
	}
	updateHeight(node); // 更新节点高度

	/* 2. 执行旋转操作，使该子树重新恢复平衡 */
	node = rotate(node);

	// 返回子树的根节点
	return node;
}

/* 删除节点 */
void remove(TreeNode* root, int val)
{
	root = removeHelper(root, val);
}

/* 查找节点 */
TreeNode* search(TreeNode* root, int num)
{
	TreeNode* cur = root;
	// 循环查找，越过叶节点后跳出
	while (cur != nullptr)
	{
		// 目标节点在 cur 的右子树中
		if (cur->val < num)
		{
			cur = cur->right;
		}
		// 目标节点在 cur 的左子树中
		else if (cur->val > num)
		{
			cur = cur->left;
		}
		// 找到目标节点，跳出循环
		else
		{
			break;
		}
	}
	// 返回目标节点
	return cur;
}