【数据结构】AVL树

最新推荐文章于 2024-03-07 20:07:59 发布
最新推荐文章于 2024-03-07 20:07:59 发布
阅读量1k 收藏 30
点赞数 35
分类专栏： 数据结构 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66314292/article/details/129163342
版权

AVL树

一、AVL树的概念

当我们用普通的搜索树插入数据的时候，如果插入的数据是有序的，那么就退化成了一个链表，搜索效率低下。

为了应对这种情况，就出现了AVL树（高度平衡二叉搜索树）：

当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1

AVL树的性质：

  • 它的左右子树都是AVL树。
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1

平衡因子= 右子树高度-左子树高度

在这里插入图片描述
平衡因子是用来检测树的状态，如果平衡因子都在（-1， 0， 1）中，则没问题，反之则需要调整。

二、AVL的接口

AVL的节点定义：

template <class K, class V>
struct AVLNode
{
	AVLNode(const pair<K, V>& kv)
		: _kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)
	{}

	pair<K, V> _kv;
	AVLNode<K, V>* _left;
	AVLNode<K, V>* _right;
	AVLNode<K, V>* _parent;
	int _bf;// 平衡因子
};

2.1 插入

AVL的基本插入流程跟搜索树相似，但是AVL树多了一个平衡因子。
一旦插入新节点，就要往上更新平衡因子。

  • 如果是在左边点插入，则平衡因子--
  • 如果是在右边点插入，则平衡因子++

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
更新一个结点之后我们需要去进行判断，子树的高度是否发生了变化：

1️⃣ 当父节点的平衡因子变成0：说明原来是-1或1，那么也就是把矮的地方填平了，父节点所在树的高度不变，不需要继续更新。
2️⃣ 当父节点的平衡因子变成1或-1：说明原来是0，父节点所在树的高度发生变化，需要继续更新。
3️⃣ 当当父节点的平衡因子变成2或-2：违反规则，需要进行旋转处理。

所以我们可以利用parent节点（插入之前的叶子节点），从它开始往上更新。

bool insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
	{
		_root = new Node(kv);
		return true;
	}

	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (kv.first < cur->_kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (kv.first > cur->_kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else return false;
	}
	cur = new Node(kv);
	if (kv.first < parent->_kv.first)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}
	cur->_parent = parent;
	// 更新平衡因子
	while (parent)
	{
		if (cur == parent->_left) parent->_bf--;
		else parent->_bf++;
		if (parent->_bf == 0) break;
		else if (parent->_bf == 1 || parent->_bf == -1)
		{
			cur = parent;
			parent = parent->_parent;
		}
		else if (parent->_bf == 2 || parent->_bf == -2)
		{
			// 旋转
			if (parent->_bf == 2 && cur->_bf == 1)
			{
				// 左单旋
				RotateL(parent);
			}
			else if (parent->_bf == -2 && cur->_bf == -1)
			{
				// 右单旋
				RotateR(parent);
			}
			else if (parent->_bf == -2 && cur->_bf == 1)
			{
				// 左右双旋
				RotateLR(parent);
			}
			else if (parent->_bf == 2 && cur->_bf == -1)
			{
				// 右左双旋
				RotateRL(parent);
			}
			break;
		}
		else
		{
			cout << "结构出错" << endl;
			assert(false);
		}
	}
	return true;
}

2.2 旋转

为了保证每个结点的左右子树高度之差的绝对值不超过1，所以当平衡因子变为-2或2时，需要旋转来保持平衡。
旋转规则：
1️⃣ 让这颗子树左右高度差不超过1
2️⃣ 旋转过程中继续保持它是搜索树
3️⃣ 更新调整孩子节点的平衡因子
4️⃣ 让这颗子树的高度根插入前保持一致

2.2.1 左单旋

二叉树的结构有无数种情况，所以我们需要总结出抽象图来分析
在这里插入图片描述
解释：
a/b/c是高度为h的AVL树。

新节点插入较高右子树的右侧—右右：左单旋
在这里插入图片描述
左单旋的步骤：

1️⃣ 20的左边调整到10的右边
2️⃣ 10变成20的左边，20做根
3️⃣ 把平衡因子变为0

在这里插入图片描述

void RotateL(Node* parent)
{
	Node* top = parent->_parent;
	Node* right = parent->_right;
	// 20的左边调整到10的右边
	parent->_right = right->_left;
	if (right->_left) right->_left->_parent = parent;
	// 10变成20的左边，20做根
	right->_left = parent;
	parent->_parent = right;
	if (top)// 子树
	{
		if (parent == top->_left) top->_left = right;
		else top->_right = right;
		right->_parent = top;
	}
	else// 完整的树
	{
		_root = right;
		_root->_parent = nullptr;
	}
	// 更新平衡因子
	parent->_bf = right->_bf = 0;
}

2.2.2 右单旋

新节点插入较高左子树的左侧—左左：右单旋
在这里插入图片描述在这里插入图片描述

void RotateR(Node* parent)
{
	Node* top = parent->_parent;
	Node* left = parent->_left;
	Node* leftR = left->_right;
	parent->_left = leftR;
	if (leftR) leftR->_parent = parent;
	left->_right = parent;
	parent->_parent = left;
	if (top)
	{
		if (parent == top->_left) top->_left = left;
		else top->_right = left;
		left->_parent = top;
	}
	else
	{
		_root = left;
		_root->_parent = nullptr;
	}
	parent->_bf = left->_bf = 0;
}

2.2.3 左右双旋

新节点插入较高左子树的右侧—左右：先左单旋再右单旋

我们看到上面的单旋，我们会想，如果是这么插入呢？
在这里插入图片描述

其实这个图可以转化为：

在这里插入图片描述
先以10为轴进行左单旋，这样就把“折线”变成了直线，在以20为轴进行右单旋。
在这里插入图片描述
这里就要注意平衡因子的更新
15的平衡因子为0
但是其他两个会有三个不同的情况：

1️⃣ 当right的平衡因子为-1时（插入在b），双旋结束后parent、left、right的平衡因子分别更新为1、0、0
在这里插入图片描述
2️⃣ 当right的平衡因子为1时（插入在c），双旋结束后parent、left、right的平衡因子分别更新为0、-1、0
在这里插入图片描述
3️⃣ 当right的平衡因子为0时，双旋后parent、left、right的平衡因子分别更新为0、0、0
在这里插入图片描述

所以在旋转前要先进行判断在哪插入（通过平衡因子），旋转后手动更新即可。

void RotateLR(Node* parent)
{
	Node* left = parent->_left;
	Node* right = left->_right;
	int bf = right->_bf;// 提前记录
	RotateL(parent->_left);
	RotateR(parent);
	if (bf == -1)// 左子树新增
	{
		left->_bf = 0;
		right->_bf = 0;
		parent->_bf = 1;
	}
	else if (bf == 1)// 右子树新增
	{
		left->_bf = -1;
		right->_bf = 0;
		parent->_bf = 0;
	}
	else if (bf == 0)// 自己就是新增
	{
		left->_bf = right->_bf = parent->_bf = 0;
	}
	else assert(false);
}

2.2.4 右左双旋

	void RotateRL(Node* parent)
	{
		Node* right = parent->_right;
		Node* left = right->_left;
		int bf = left->_bf;
		RotateR(right);
		RotateL(parent);
		if (bf == -1)
		{
			parent->_bf = 0;
			left->_bf = 0;
			right->_bf = 1;
		}
		else if (bf == 1)
		{
			right->_bf = 0;
			left->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == 0)
		{
			left->_bf = right->_bf = parent->_bf = 0;
		}
		else assert(false);
	}

三、验证

为了验证是否为二叉搜索树，我们可以先写一个中序遍历

void _Inorder(Node* root)
{
	if (root == nullptr)
		return;

	_Inorder(root->_left);
	cout << root->_kv.first << ":" << root->_kv.second << endl;
	_Inorder(root->_right);
}

void Inorder()
{
	_Inorder(_root);
}

为了验证是否为AVL树，我们要让每个节点的左右子树高度的绝对值差小于等于1。

int Height(Node* root)
{
	if (!root)
	{
		return 0;
	}
	int lh = Height(root->_left) + 1;
	int rh = Height(root->_right) + 1;
	return max(lh, rh);
}

bool IsBalance(Node* root)
{
	if (!root)
	{
		return true;
	}
	int lh = Height(root->_left);
	int rh = Height(root->_right);
	if (rh - lh != root->_bf)
	{
		cout << root->_kv.first << ":";
		cout << root->_bf << ":";
		cout << "平衡因子出错" << endl;
		return false;
	}
	if (abs(rh - lh) > 1)
	{
		return false;
	}
	return IsBalance(root->_left) && IsBalance(root->_right);
}

bool IsBalance()
{
	return IsBalance(_root);
}

我们可以用大量的随机值来测定：

void test()
{
	const int N = 100000;
	AVLTree<int, int> tt;
	srand(time(0));
	for (int i = 0; i < N; i++)
	{
		int x = rand();
		tt.insert(make_pair(x, x));
	}
	//tt.Inorder();
	cout << tt.IsBalance() << endl;
}

四、源码

#pragma once
#include <iostream>
#include <string>
#include <cassert>
#include <cstdlib> 

using namespace std;

template <class K, class V>
struct AVLNode
{
	AVLNode(const pair<K, V>& kv)
		: _kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)
	{}

	pair<K, V> _kv;
	AVLNode<K, V>* _left;
	AVLNode<K, V>* _right;
	AVLNode<K, V>* _parent;
	int _bf;// 平衡因子
};


template <class K, class V>
class AVLTree
{
	typedef AVLNode<K, V> Node;
public:
	bool insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else return false;
		}
		cur = new Node(kv);
		if (kv.first < parent->_kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;
		// 更新平衡因子
		while (parent)
		{
			if (cur == parent->_left) parent->_bf--;
			else parent->_bf++;
			if (parent->_bf == 0) break;
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				// 旋转
				if (parent->_bf == 2 && cur->_bf == 1)
				{
					// 左单旋
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == -1)
				{
					// 右单旋
					RotateR(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					// 左右双旋
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					// 右左双旋
					RotateRL(parent);
				}
				break;
			}
			else
			{
				cout << "结构出错" << endl;
				assert(false);
			}
		}
		return true;
	}

	void RotateL(Node* parent)
	{
		Node* top = parent->_parent;
		Node* right = parent->_right;
		// 20的左边调整到10的右边
		parent->_right = right->_left;
		if (right->_left) right->_left->_parent = parent;
		// 10变成20的左边，20做根
		right->_left = parent;
		parent->_parent = right;
		if (top)// 子树
		{
			if (parent == top->_left) top->_left = right;
			else top->_right = right;
			right->_parent = top;
		}
		else// 完整的树
		{
			_root = right;
			_root->_parent = nullptr;
		}
		// 更新平衡因子
		parent->_bf = right->_bf = 0;
	}

	void RotateR(Node* parent)
	{
		Node* top = parent->_parent;
		Node* left = parent->_left;
		Node* leftR = left->_right;
		parent->_left = leftR;
		if (leftR) leftR->_parent = parent;
		left->_right = parent;
		parent->_parent = left;
		if (top)
		{
			if (parent == top->_left) top->_left = left;
			else top->_right = left;
			left->_parent = top;
		}
		else
		{
			_root = left;
			_root->_parent = nullptr;
		}
		parent->_bf = left->_bf = 0;
	}

	void RotateLR(Node* parent)
	{
		Node* left = parent->_left;
		Node* right = left->_right;
		int bf = right->_bf;// 提前记录
		RotateL(left);
		RotateR(parent);
		if (bf == -1)// 左子树新增
		{
			left->_bf = 0;
			right->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)// 右子树新增
		{
			left->_bf = -1;
			right->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 0)// 自己就是新增
		{
			left->_bf = right->_bf = parent->_bf = 0;
		}
		else assert(false);
	}

	void RotateRL(Node* parent)
	{
		Node* right = parent->_right;
		Node* left = right->_left;
		int bf = left->_bf;
		RotateR(right);
		RotateL(parent);
		if (bf == -1)
		{
			parent->_bf = 0;
			left->_bf = 0;
			right->_bf = 1;
		}
		else if (bf == 1)
		{
			right->_bf = 0;
			left->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == 0)
		{
			left->_bf = right->_bf = parent->_bf = 0;
		}
		else assert(false);
	}

	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;

		_Inorder(root->_left);
		cout << root->_kv.first << "<=>" << root->_kv.second << endl;
		_Inorder(root->_right);
	}

	void Inorder()
	{
		_Inorder(_root);
	}

	int Height(Node* root)
	{
		if (!root)
		{
			return 0;
		}
		int lh = Height(root->_left) + 1;
		int rh = Height(root->_right) + 1;
		return max(lh, rh);
	}

	bool IsBalance(Node* root)
	{
		if (!root)
		{
			return true;
		}
		int lh = Height(root->_left);
		int rh = Height(root->_right);
		if (rh - lh != root->_bf)
		{
			cout << root->_kv.first << ":";
			cout << root->_bf << ":";
			cout << "平衡因子出错" << endl;
			return false;
		}
		if (abs(rh - lh) > 1)
		{
			return false;
		}
		return IsBalance(root->_left) && IsBalance(root->_right);
	}

	bool IsBalance()
	{
		return IsBalance(_root);
	}
private:
	Node* _root = nullptr;
};

void test()
{
	const int N = 100000;
	AVLTree<int, int> tt;
	srand(time(0));
	for (int i = 0; i < N; i++)
	{
		int x = rand();
		tt.insert(make_pair(x, x));
	}
	//tt.Inorder();
	cout << tt.IsBalance() << endl;
}
命由己造～
关注
  • 35
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 26
    评论
专栏目录
AVL树二叉链表实现类，源码
03-30
AVL树实现源码，C++实现，二叉链表 详细点的说明在博文有：http://blog.csdn.net/betabin/article/details/7410308
数据结构（高阶）—— AVL树
M的博客
11-25 1190
高阶数据结构——AVL树
AVL树实现类——二叉链表实现
BetaBin
03-30 1515
（一个人感冒咳嗽不悲剧，悲剧的是全家都感冒咳嗽，没人做事……忽冷忽热的天气得注意保暖） 首先吧，关于AVL树的知识，还是老规矩，Wiki下。 “在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得
数据结构--AVL树（全）
weixin_48560325的博客
05-01 8103
目录 什么是AVL树？ AVL树的特点及形成原因 二叉搜索树基本概念 二叉搜索的特点 二叉搜索树的优点及缺点 改进的二叉搜索树——AVL树 AVL树的定义 AVL树的特点 结点的平衡因子balance 构建一个AVL树 构建一个AVL树的节点 什么是AVL树？ AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 AVL树的特点及形成原因 AVL树本质.
数据结构-AVL树（平衡二叉树）
m0_61433144的博客
08-11 885
规定在插入和删除二叉搜索树的结点时，要保证任意结点的左右子树高度差的绝对值不超过1，我们将这样特殊的二叉搜索树称为AVL树（平衡二叉树）。每一个结点中有记录其左右子树高度差的平衡因子，也即平衡因子的值只可能是-1,0,1。（1如果某结点的左子树高度比右子树高度高一则平衡因子为-1，如果某结点的左子树高度比右子树高度低一则平衡因子为1，如果某结点的左子树高度与右子树高度一样则平衡因子为0）。............
数据结构 AVL树
WhiteShirtI的博客
05-17 663
AVL树 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下 平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树 平衡因子 某结点的右子树与左子树的高度(深度)差即为该结点的平衡因子。平衡二叉树上所有结点的平衡因子只可能是 -1，0 或 1 实现 结点
数据结构：AVL树
最新发布
decade777555的博客
03-07 1186
两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右 子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
图解数据结构树之AVL树
HYeeee的博客
12-28 443
图解数据结构树之AVL树 AVL树(平衡二叉树)： 　　AVL树本质上是一颗二叉查找树，但是它又具有以下特点：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为平衡二叉树。下面是平衡二叉树和非平衡二叉树对比的例图： 　　平衡因子(bf)：结点的左子树的深度减去
数据结构之AVL树详解
12-26
AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis。AVL树种查找、插入和删除在平均和最坏情况下...
华科数据结构AVL树课设
03-11
华中科技大学数据结构的基于AVL树的课程设计，要求实现Set集合和人物之间的关系操作。
数据结构avl树实现
03-18
avl树实现 数据结构数据结构数据结构数据结构
C++数据结构AVL.zip
04-20
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这...c++数据结构实现avl完美运行
SEU 数据结构作业 AVL树
10-27
某福建大三本的某三本学院的数据结构作业，题号对应清华殷人昆版。有一些可能参考借鉴了网上的代码，大体应该都能运行（尤其是大作业），仅供参考
AVL树数据结构平衡二叉查找树
07-16
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者...
数据结构-avl树
08-15
avl树的实现代码，其中部分功能代码有bug，有待进一步完善
山东大学数据结构课程设计—AVL搜索树
11-24
这是去年做的一份课程设计，用c++,visual studio6.0做的，希望对大家有用处
AVL树的C语言实现
11-30
AVL树的C语言实现
数据结构课程设计（AVL树实现图书管理系统）
02-01
数据结构课程设计（AVL树实现图书管理系统）
python 数据结构avl树
05-28
AVL树是一种自平衡二叉搜索树，它的平衡因子（左子树高度减去右子树高度）在任何时候都是-1、0或1。当插入或删除节点后，如果AVL树失去平衡，则需要通过旋转来重新平衡它。 在Python中实现AVL树，可以使用节点类和AVL树类。节点类包括节点值、左子树、右子树、高度和平衡因子等属性。AVL树类包括根节点、插入节点、删除节点、旋转方法和平衡方法等方法。 下面是一个简单的Python实现AVL树的代码示例： ```python class Node: def __init__(self, val): self.val = val self.left = None self.right = None self.height = 1 self.balance = 0 class AVLTree: def __init__(self): self.root = None def insert(self, val): self.root = self._insert(self.root, val) def _insert(self, node, val): if not node: return Node(val) if val < node.val: node.left = self._insert(node.left, val) else: node.right = self._insert(node.right, val) node.height = 1 + max(self.get_height(node.left), self.get_height(node.right)) node.balance = self.get_balance(node) if node.balance > 1 and val < node.left.val: return self.right_rotate(node) if node.balance < -1 and val > node.right.val: return self.left_rotate(node) if node.balance > 1 and val > node.left.val: node.left = self.left_rotate(node.left) return self.right_rotate(node) if node.balance < -1 and val < node.right.val: node.right = self.right_rotate(node.right) return self.left_rotate(node) return node def delete(self, val): self.root = self._delete(self.root, val) def _delete(self, node, val): if not node: return node if val < node.val: node.left = self._delete(node.left, val) elif val > node.val: node.right = self._delete(node.right, val) else: if not node.left or not node.right: temp = node.left if node.left else node.right if not temp: node = None else: node = temp else: temp = self.get_min(node.right) node.val = temp.val node.right = self._delete(node.right, temp.val) if not node: return node node.height = 1 + max(self.get_height(node.left), self.get_height(node.right)) node.balance = self.get_balance(node) if node.balance > 1 and self.get_balance(node.left) >= 0: return self.right_rotate(node) if node.balance < -1 and self.get_balance(node.right) <= 0: return self.left_rotate(node) if node.balance > 1 and self.get_balance(node.left) < 0: node.left = self.left_rotate(node.left) return self.right_rotate(node) if node.balance < -1 and self.get_balance(node.right) > 0: node.right = self.right_rotate(node.right) return self.left_rotate(node) return node def right_rotate(self, node): left_child = node.left node.left = left_child.right left_child.right = node node.height = 1 + max(self.get_height(node.left), self.get_height(node.right)) left_child.height = 1 + max(self.get_height(left_child.left), self.get_height(left_child.right)) node.balance = self.get_balance(node) left_child.balance = self.get_balance(left_child) return left_child def left_rotate(self, node): right_child = node.right node.right = right_child.left right_child.left = node node.height = 1 + max(self.get_height(node.left), self.get_height(node.right)) right_child.height = 1 + max(self.get_height(right_child.left), self.get_height(right_child.right)) node.balance = self.get_balance(node) right_child.balance = self.get_balance(right_child) return right_child def get_height(self, node): if not node: return 0 return node.height def get_balance(self, node): if not node: return 0 return self.get_height(node.left) - self.get_height(node.right) def get_min(self, node): while node.left: node = node.left return node ``` 这个实现包括插入、删除、旋转和平衡等基本操作。你可以按需调用这些方法，来实现你的具体需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

命由己造～

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

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

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

打赏作者

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

抵扣说明：

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

余额充值