AVL树的删除

原创已于 2022-06-01 15:04:31 修改 · 5.7k 阅读

43 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #算法 #C #c++

于 2021-07-05 21:11:29 首次发布

C++ 专栏收录该内容

18 篇文章

订阅专栏

本文深入解析AVL树的删除过程，包括寻找目标节点、判断类型并转化成叶子节点，以及关键的平衡调整策略。通过实例演示和代码说明，确保在删除后维持AVL树的特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

AVL树的删除

引言

AVL树的定义及性质及其重要的插入方法，我已在AVL树的插入一文中详细阐述过了，其中重要的旋转也已进行详细描述。

本文就不再赘述了，直接使用，要是不清楚的小伙伴，还请移步AVL树的插入再回头复习一下下。

AVL树的删除

AVL树的删除步骤如下：

寻找删除目标（存不存在，定位出目标）
判断删除目标的类型，使用转换的思路，将其转化为删除叶子
将删除目标与AVL树链接断开，调整平衡，完成删除

寻找删除目标

寻找删除目标的思路很简单，因AVL树也属于BST，因此寻找目标的做法与BST的删除思路基本一致。

但！但！但因为删除节点可能会导致AVL树的失衡，因此不能像BST的删除那样一删了事，它还需要删后调整，而调整牵涉的节点就是从根节点开始到删除目标路径上的所有节点。

因此在搜索的过程，与BST删除略有不同的就是，AVL树在搜寻删除目标的过程中，需要存储这条路径上的所有节点，以供后续回溯调整时使用。

删除函数声明为bool Remove(Node*& t, const Ty& key)，其中t为AVL的树根，key为删除目标值

Node* parent = nullptr;
Node* p = t, * q = nullptr;
stack<Node*> st;
//p是指向AVL树的根节点的一个指针
while (p) {		
	if (p->val == key)//当前节点就是删除目标
		break;
	parent = p;
	st.push(parent);//存储轨迹
	if (key > p->val)//删除目标在右树
		p = p->right;
	else//删除目标在左树
		p = p->left;
}
//执行到此处，p要么为预想的删除目标，要么为nullptr（即不存在）
//下一步应该是判断删除目标的类型，进行转化

判断删除类型，进行转化

说起删除目标的类型，只有两种：

删除目标存在两个子树(或节点)
删除目标最多仅有1个子女

删除目标存在两个子女

下图即是该情况的处理手段：
在这里插入图片描述
利用转化思想将非叶子节点转化为删除叶子节点，难度大大降低。

删除目标最多仅有1个子节点

只有一个子节点，非常容易处理，我们只需要令删除目标的父节点链接删除目标的子节点，再删除目标即可。如下图所示：
在这里插入图片描述
当然在这里面存在一种较特殊的情况，即整棵树只有两个节点，且删除目标是根节点。这种情况下我们直接令子节点成为根节点即可。如下：

删除一个节点就是如此简单，归根结底最后的删除类型只有一种：删除目标最多仅有1个子节点

此部分代码大致如下：

if (p==nullptr)//删除目标不存在
	return false;
//删除节点
if (p->left && p->right) {//删除目标左右皆有
	parent = p;
	q = p->left;
	st.push(parent);
	while (q->right) {
		parent = q;
		st.push(parent);
		q = q->right;
	}
	p->val = q->val;
	p = q;//转化为删前驱
}
//p是删除目标,q是删除目标的子女节点
if (p->left)
	q = p->left;
else
	q = p->right;
if (parent==nullptr)//删除目标是整棵AVL的根节点
	t = q;
else {
	//断开p节点，链接它的子女q
	if (parent->left == p) //删除目标是左孩子
		parent->left = q;
	else//删除目标是右孩子
		parent->right = q;
}
//下一步应该是调整平衡

但接下来的才是重中之重，那就是调整平衡，因为删除节点，必然引起路径上某些节点的平衡因子，被删目标的父节点首当其冲。

因此确定真正的删除目标后，需要根据存储的路径向上回溯调整结构，维持AVL树的性质。

调整平衡

上文可以得出本文在代码中是定义p为删除目标，因此下文沿用。

首先，我们应明白的是：

若p是其父节点parent的左子女，删除p，引起左树高度降低，因此parent的平衡因子需要+1；
若p是其父节点parent的右子女，删除p，引起右树高度降低，因此parent的平衡因子需要-1；
因为parent的父节点也会受parent的影响，因此有可能也需要调整，所以有可能这个调整需要不断往上追溯。

调整平衡需要分3种情况：

1.`parent`的平衡因子原来为0

在这里插入图片描述

这种情况下，无论删除parent的左子树还是右子树上的节点，但是不会影响到以parengt为父节点的子树高度，因此这种情况下只需要改变parent的平衡因子即可:0------>1/-1

2. `parent`的平衡因子原来绝对值为1，且被删节点位于较高的子树

在这里插入图片描述
可以发现，该种情况下，删除支树上的节点将使得parent的平衡因子变为0。但由于删除使得该支树高度减1，因此需要向上平衡，沿着栈中存储的路径回溯。

因此，父节点平衡因子改动后并不意味着完成了平衡，而要追溯修改更上层的祖先节点。

3. `parent`的平衡因子原来绝对值为1，且被删节点位于较矮的子树

在这种情况下，删除较矮子树上的节点，parent的平衡因子会变为2/-2，parent失衡，光是调整平衡因子已经不能解决问题，而是需要旋转操作进行再平衡。

情况1：

parent的平衡因子为2，q的平衡因子为0，执行一次左单旋即可结束平衡工作；反之，parent的平衡因子为-2，q的平衡因子为0，执行一次右单旋即可结束平衡工作；

情况2：

parent的平衡因子与q的平衡因子同符号，则可以使用一个单旋转进行再平衡。如下图所示，二者皆为正，进行一次左旋即可平衡目前的支树结构。但由于旋转导致parent的父节点高度减1，所以需要继续向上考察路径中的平衡状态。

情况3：

parent的平衡因子与q的平衡因子异符号，则需要使用双旋转进行再平衡。但由于旋转导致parent的父节点高度减1，所以需要继续向上考察路径中的平衡状态。

AVL类代码

#include <iostream>
#include <vector>
#include <stack>
#include <vld.h>
using namespace std;

template<class Ty>
class AVLTree;

template<class Ty>
class AVLNode {
	friend class AVLTree<Ty>;
public:
	AVLNode() :val(Ty()), bf(0),left(nullptr),right(nullptr){}
	AVLNode(Ty _val = Ty(),int _bf = 0, AVLNode<Ty>* l = nullptr, AVLNode<Ty>* r = nullptr) :
		val(_val), bf(_bf),left(l), right(r) {}
	~AVLNode() {
		left = nullptr;
		right = nullptr;
		bf = 0;
	}
private:
	AVLNode<Ty>* left;
	AVLNode<Ty>* right;
	Ty val;
	int bf;
};

template<class Ty>
class AVLTree {
	typedef AVLNode<Ty> Node;
public:
	AVLTree() :root(nullptr) {}
	AVLTree(const vector<Ty>& v) :root(nullptr) {
		for (auto& e : v)
			Insert(e);
	}
	~AVLTree() {
		while (root!=nullptr)
			Remove(root->val);
	}
public:
	bool Insert(const Ty& data) { return Insert(root, data); }
	bool Remove(const Ty& key) { return Remove(root, key); }
	void InOrder() { return InOrder(root); }
protected:
	bool Insert(Node*& t, const Ty& data) {
		//先按BST插入节点，寻找插入位置过程中存储轨迹
		Node* parent = nullptr;
		Node* p = t;
		stack<Node*> st;
		while (p){
			if (p->val == data)//重复数据不可插入
				return false;
			parent = p;
			st.push(parent);
			if (data > p->val)
				p = p->right;
			else
				p = p->left;
		}
		p = new Node(data);
		if (!parent) {//空树
			t = p;
			return true;
		}
		if (p->val > parent->val)//左小右大插入
			parent->right = p;
		else
			parent->left = p;
		//调整树，使BST->AVL
		while (!st.empty()) {
			parent = st.top();
			st.pop();
			if (p == parent->left)//左树升高
				--parent->bf;
			else
				++parent->bf;
			if (!parent->bf)//父节点平衡
				break;
			else if (parent->bf == 1 || parent->bf == -1) 
				p = parent;//向上回溯
			else {//本节点不平衡，需要调整
				if (parent->bf < 0) {
					if (p->bf < 0)//右旋(/)
						RotateR(parent);
					else//左右双旋(<)
						RotateLR(parent);
				}
				else {
					if (p->bf > 0)//左旋(\)
						RotateL(parent);
					else//右左双旋(>)
						RotateRL(parent);
				}
				break;//已平衡，跳出
			}
		}
		//因旋转导致的原不平衡的节点被两次指向，需要调整
		if (st.empty())
			t = parent;
		else {
			Node* q = st.top();
			if (parent->val < q->val)
				q->left = parent;
			else
				q->right = parent;
		}
		return true;
	}
	bool Remove(Node*& t, const Ty& key) {
		Node* parent = nullptr;
		Node* p = t, * q = nullptr;
		stack<Node*> st;
		while (p) {		//先找到节点，存储轨迹
			if (p->val == key)
				break;
			parent = p;
			st.push(parent);
			if (key > p->val)
				p = p->right;
			else
				p = p->left;
		}
		if (p==nullptr)//删除目标不存在
			return false;
		//删除节点
		if (p->left && p->right) {//删除目标左右皆有
			parent = p;
			q = p->left;
			st.push(parent);
			while (q->right) {
				parent = q;
				st.push(parent);
				q = q->right;
			}
			p->val = q->val;
			p = q;//转化为删前驱
		}
		//p是删除目标,q是删除目标的子女节点
		if (p->left)
			q = p->left;
		else
			q = p->right;
		bool Isleft = false;
		if (parent==nullptr)//删除目标是整棵AVL的根节点
			t = q;
		else {
			//断开p节点，链接它的子女q
			if (parent->left == p) { //删除目标是左孩子
				parent->left = q;
				Isleft = true;
			}
			else//删除目标是右孩子
				parent->right = q;
		}
		//调整平衡
		bool isbanlanced = false;
		while (!st.empty()) {
			parent = st.top();
			st.pop();
			if(Isleft)
				++parent->bf;
			else
				--parent->bf;
			if (parent->bf == 1 || parent->bf == -1)//平衡
				break;
			if (0 == parent->bf) { //向上回溯调整
				q = parent;
				if(st.size())//重置isleft
					Isleft = st.top()->left == q ? true : false;
			}
			else {//parent失衡
				if (parent->bf > 0)//令q指向较高的树
					q = parent->right;
				else
					q = parent->left;
				if (q->bf == 0){//单旋转
					if (parent->bf < 0){
						RotateR(parent);
						parent->bf = 1;
						parent->right->bf = -1;
					}
					else{
						RotateL(parent);
						parent->bf = -1;
						parent->left->bf = 1;
					}
					isbanlanced = true;
				}
				else {
					if (parent->bf < 0) {
						if (q->bf < 0)  //   /
							RotateR(parent);
						else           //   <
							RotateLR(parent);
					}
					else {
						if (q->bf > 0)  //   \ 
							RotateL(parent);
						else           //   >
							RotateRL(parent);
					}
				}
				//重新链接
				if (st.empty())
					t = parent;
				else {
					q = st.top();
					if (parent->val < q->val)
						q->left = parent;
					else
						q->right = parent;
				}
				if (isbanlanced)
					break;
			}
		}
		delete p;
		return true;
	}
	void InOrder(Node*& root) {
		if (root) {
			InOrder(root->left);
			cout << root->val << " ";
			InOrder(root->right);
		}
	}
private:
	void RotateL(Node*& t) {
		Node* subL = t;
		t = subL->right;//子节点将变父节点
		subL->right = t->left;//子节点的左树成为父节点的右树
		t->left = subL;//父节点左旋
		subL->bf = t->bf = 0;
	}
	void RotateR(Node*& t) {
		Node* subR = t;
		t = subR->left;//子节点将变父节点
		subR->left= t->right;//子节点的右树成为父节点的左树
		t->right = subR;//父节点右旋
		subR->bf = t->bf = 0;
	}
	void RotateLR(Node*& t) {
		Node* subL, * subR;
		subR = t;
		subL = subR->left;
		t = subL->right;

		subL->right = t->left;
		t->left = subL;
		if (t->bf <= 0)
			subL->bf = 0;
		else 
			subL->bf = -1;
		subR->left = t->right;
		t->right = subR;
		if (t->bf >= 0)
			subR->bf = 0;
		else
			subR->bf = 1;
		t->bf = 0;
	}
	void RotateRL(Node*& t) {
		Node* subL, * subR;
		subL = t;
		subR = subL->right;
		t = subR->left;

		subR->left =  t->right;
		t->right = subR;
		if (t->bf >= 0)
			subR->bf = 0;
		else
			subR->bf = 1;

		subL->right = t->left;
		t->left = subL;
		if (t->bf <= 0)
			subL->bf = 0;
		else
			subL->bf = -1;

		t->bf = 0;
	}
private:
	Node* root;
};
int main() {
	vector<int> iv{ 16, 3, 7 , 11, 9, 26, 18, 14, 15 };
	AVLTree<int> avl(iv);
	avl.Remove(7);
	avl.Remove(16);
	avl.Remove(3);
	avl.Remove(15);
	avl.Remove(3);
	avl.Remove(18);
	avl.Remove(14);
	avl.Remove(26);
	avl.Remove(9);
	return 0;
}