探索数据结构：AVL树的分析与实现

已于 2024-08-17 13:51:09 修改
阅读量1.1k 收藏 14
点赞数 16
分类专栏： 数据结构与算法 文章标签： 数据结构 C++ AVL树 平衡二叉搜索树
于 2024-08-14 17:24:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bettysweetyaaa/article/details/141195956
版权

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：数据结构与算法
贝蒂的主页：Betty’s blog

1. AVL树的介绍

在前面我们学习二叉搜索树时知道，在数据有序或接近有序时二叉搜索树会退化为单边树，查找时相当于在单链表中查找，效率低下。

img

为了解决这个问题，1962 年，两位俄罗斯数学家G.M.Adelson-Velskii和E.M.Landis提出了一种新方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。而这颗新的树我们平衡二叉搜索（排序）树，简称AVL树。其具有以下特点：

  1. AVL树本质就是一颗二叉搜索树。
  2. AVL树左右两棵子树的高度差的绝对值(平衡因子)不超过1。
  3. AVL树的左右两棵子树也是一颗AVL树。

其中特别注意：空树也是一颗AVL树，并且由于AVL树也是二叉搜索树，所以AVL树的中序遍历是有序的。

img

AVL树通过特殊的构造有效的避免了二叉搜索树在数据有序或接近有序时退化为单边树的情况。这使得AVL树在查找、插入和删除操作上，能够保持较为稳定的时间复杂度，而不会因为数据的特殊分布导致性能急剧下降。

2. AVL树的功能

以下是常见的AVL树的功能：

  1. AVL树的插入。
  2. AVL树的查找。
  3. AVL树的删除。

3. AVL树的结构

3.1. AVL树的节点

AVL树的节点本质与二叉搜索树的节点差不多，所以肯定有三个成员变量：左子树_left，右子树_right，键值_val，并且键值我们采用KV模型的形式。而为了后续调整我们还需一个平衡因子_bf(默认为右子树的高度-左子树的高度)以及一个父节点_parent。当然为了适配不同的类型，我们可以定义一个模版.。

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode(const pair<K, V>& val = pair<K, V>())
		:_kv(val)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_bf(0)
	{}
	pair<K, V> _kv;//kv模型
	int _bf;//平衡因子
	AVLTreeNode* _left;//左子树
	AVLTreeNode* _right;//右子树
	AVLTreeNode* _parent;//指向父节点
};

3.2. AVL树

然后我们就可以通过节点来定义AVL树，并将根节点初始化为空。

template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	//...具体功能
private:
	Node* _root = nullptr;//根节点
};

4. AVL树的初始化与销毁

4.1. 构造函数/拷贝构造/赋值重载

首先我们直接定义一个无参的构造函数，因为我们在定义拷贝构造之后编译器就不会在生成默认的构造函数了。

AVLTree()
{}

之后我们可以利用递归来实现一个拷贝构造函数。

AVLTree(const AVLTree& t)
{
    _root = copy(t._root);
}
Node* copy(Node* root)
{
    // 如果传入的根节点为空，直接返回空指针，表示拷贝结束
    if (root == nullptr)
        return nullptr;
    // 为新树创建一个与原始根节点值相同的新节点
    Node* newnode = new Node(root->_kv);
    // 递归地拷贝原始根节点的左子树，并将结果赋给新节点的左指针
    newnode->_left = copy(root->_left);
    // 递归地拷贝原始根节点的右子树，并将结果赋给新节点的右指针
    newnode->_right = copy(root->_right);
    // 新节点的父节点默认为空
    newnode->_parent = nullptr;
    // 如果新节点的左子节点存在，设置其父节点为新节点
    if (newnode->_left)
    {
        newnode->_left->_parent = newnode;
    }
    // 如果新节点的右子节点存在，设置其父节点为新节点
    if (newnode->_right)
    {
        newnode->_right->_parent = newnode;
    }
    // 返回新树的根节点指针
    return newnode;
}

最后我们通过一个简单的方式实现赋值重载——通过形参调用拷贝构造出一个临时变量，然后交换this所指向的变量，这样原本this所指向的对象出了作用域就会销毁，间接实现了实现赋值重载。

AVLTree<K,V>& operator=(const AVLTree <K,V> t)
{
    //赋值重载
    this->swap(_root, t._root);
    return *this;
}

4.2. 析构函数

析构函数需要借助递归释放所有节点，而为了方便我们传参我们可以定义子函数来帮助我们解决。

~AVLTree()
{
    Destroy(_root);
}
void Destroy(Node*& root)
{
	if (root == nullptr)
	{
		return;
	}
	//递归销毁左子树
	Destroy(root->_left);
	//递归销毁右子树
	Destroy(root->_right);
	//销毁根节点
	delete root;
	root = nullptr;
}

5. AVL树的功能实现

5.1. AVL树的旋转

我们知道AVL树左右子树的高度差绝对值要保证不超过1，也就是说AVL树的平衡因子_bf只能取-1，0，1三个值。而无论插入还是删除都可能破坏原有的结构，导致AVL树失衡。为了重新平衡AVL树，我们需要重新对其调整。

首先我们可以将AVL树被破坏的情形可以抽象成以下四种场景，其中红色字体代表该节点的平衡因子，蓝色节点代表破坏AVL树平衡的节点。

5.1.1. 右单旋

首先第一种情况就是破坏AVL树平衡的节点位于较高左子树的左侧。

img

对于这种情况我们需要右单旋的方式，设失衡节点为_parent，其左子树节点为subL，而左子树的右子树为subLR。其调整规则如下：

  1. 将subLR链接到parent的左边。
  2. 将parent链接到subL的右边。
  3. 将parent与subL的平衡因子置为0。

img

void RotateR(Node*&parent)
{
	// 获取父节点的左子节点
	Node* subL = parent->_left;
	// 获取父节点左子节点的右子节点
	Node* subLR = subL->_right;

	// 1.将subLR链接到parent的左边。
	parent->_left = subLR;
	// 如果父节点左子节点的右子节点存在，设置其父节点为当前父节点
	if (subLR)
	{
		subLR->_parent = parent;
	}
	// 获取父节点的父节点
	Node* ppNode = parent->_parent;
	// 2.将parent链接到subL的右边。
	subL->_right = parent;
	//parent的父节点指向subL
	parent->_parent = subL;
	// 如果父节点存在父节点
	if (ppNode)
	{
		// 如果父节点是其父亲节点的左子节点
		if (ppNode->_left == parent)
		{
			// 将父节点的父亲节点的左子节点设置为当前父节点的左子节点
			ppNode->_left = subL;
		}
		// 如果父节点是其父亲节点的右子节点
		else
		{
			// 将父节点的父亲节点的右子节点设置为当前父节点的左子节点
			ppNode->_right = subL;
		}
		// 设置父节点左子节点的父节点为父节点的父节点
		subL->_parent = ppNode;
	}
	// 如果父节点为根节点
	else
	{
		// 将根节点设置为父节点的左子节点
		_root = subL;
		// 将父节点左子节点的父节点设置为空
		subL->_parent = nullptr;
	}
	//3.将parent与subL的平衡因子置为0。
	subL->_bf = parent->_bf = 0;
	//改变parent节点的指向，方便erase中的node返回
	parent = subL;
}

其中需要特别注意的就是：判断父节点_parent到底是根节点，还是某个节点的子节点。

5.1.2. 左单旋

第二种情况就是破坏AVL树平衡的节点位于较高右子树的右侧。

img

对于这种情况我们需要左单旋的方式，设失衡节点为_parent，其右子树节点为subR，而有右子树的左子树为subRL。其调整规则如下：

  1. 将subRL链接到parent的右边。
  2. 将parent链接到subR的左边。
  3. 将parent与subR的平衡因子置为0。

img

void RotateL(Node* &parent)
{
	// 获取父节点的右子节点
	Node* subR = parent->_right;
	// 获取父节点右子节点的左子节点
	Node* subRL = subR->_left;
	//1.将subRL链接到parent的右边。
	parent->_right = subRL;
	// 如果父节点右子节点的左子节点存在，设置其父节点为当前父节点
	if (subRL)
	{
		subRL->_parent = parent;
	}
	// 获取父节点的父节点
	Node* ppNode = parent->_parent;
	//2.将parent链接到subR的左边。
	subR->_left = parent;
	// 设置父节点的父节点为右子节点
	parent->_parent = subR;

	// 如果父节点存在父节点
	if (ppNode)
	{
		// 如果父节点是其父亲节点的左子节点
		if (ppNode->_left == parent)
		{
			// 将父节点的父亲节点的左子节点设置为当前父节点的右子节点
			ppNode->_left = subR;
		}
		// 如果父节点是其父亲节点的右子节点
		else
		{
			// 将父节点的父亲节点的右子节点设置为当前父节点的右子节点
			ppNode->_right = subR;
		}
		// 设置父节点右子节点的父节点为父节点的父节点
		subR->_parent = ppNode;
	}
	// 如果父节点为根节点
	else
	{
		// 将根节点设置为父节点的右子节点
		_root = subR;
		// 将父节点右子节点的父节点设置为空
		subR->_parent = nullptr;
	}
	// 3.将parent与subR的平衡因子置为0。
	subR->_bf = parent->_bf = 0;
	//改变parent节点的指向，方便erase中的node返回
	parent = subR;
}

其中需要特别注意的就是：判断父节点**_parent**到底是根节点，还是某个节点的子节点。

5.1.3. 先左单旋，再右单旋

第三种情况就是破坏AVL树平衡的节点位于较高左子树的右侧。

img

对于这种情况我们需要先左单旋，再右单旋的方式，设失衡节点为_parent，其左子树节点为subL，而有左子树的右子树为subLR。其调整规则如下：

  1. 先对subL进行左单旋。
  2. 在对parent进行右单旋。
  3. 调整平衡因子。

img

img

但是平衡因子的调整又可以分别三种情况：

  1. 当subLR = -1时，如上图所示，调整后subL = 0，subLR = 0，parent = 1。
  2. 当subLR = 0，即h = 0时：

比如依次插入三个节点，10，5，6，如下图所示：

img

调整后subL = 0，subLR = 0，parent = 0。

  1. 当subLR = 1时，具体情况如下图：

img

img

调整后subL = -1，subLR = 0，parent = 0。

最后我们可以总结一下：

  • 当subLR = 0时：调整为subLR = 0，subL = 0，parent = 0。
  • 当subLR = -1时：调整为subLR = 0，subL = 0，parent = 1。
  • 当subLR = 1时：调整为subLR = 0，subL = -1，parent = 0。
void RotateLR(Node*&parent)
{
    //提前记录关键节点，防止旋转之后找不到
	Node* cur = parent;
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	int bf = subLR->_bf;
	//先左旋
	RotateL(parent->_left);
	//再右旋
	RotateR(parent);
	//1.情况1
	if (bf == 0)
	{
		cur->_bf = subL->_bf = subLR->_bf = 0;
	}
	//2.情况2
	else if (bf == -1)
	{
		cur->_bf = 1;
		subL->_bf = 0;
		subLR->_bf = 0;
	}
	//3.情况3
	else if (bf == 1)
	{
		cur->_bf = 0;
		subL->_bf = -1;
		subLR->_bf = 0;
	}
	else
	{
		//走到这里说明AVL树有问题
		assert(false);
	}
}
  • 特别注意：这里需要提前记录关键节点，防止旋转时发生改变而找不到。
5.1.4. 先右单旋，再左单旋

最后一种情况就是破坏AVL树平衡的节点位于较高右子树的左侧。

img

对于这种情况我们需要先右单旋，再左单旋的方式，设失衡节点为_parent，其右子树节点为subR，而有右子树的左子树为subRL。其调整规则如下：

  1. 先对subR进行右单旋。
  2. 在对parent进行左单旋。
  3. 调整平衡因子。

img

img

同理，平衡因子的调整又可以分别三种情况：

  1. 当subRL = -1时，如上图所示，调整后subR = 1，subRL = 0，parent = 0。
  2. 当subRL = 0，即h = 0时：

比如依次插入三个节点，5，10，6，如下图所示：

img

调整后subR = 0，subRL = 0，parent = 0。

  1. 当subRL = 1时，具体情况如下图：

img

img

调整后subR = 0，subRL = 0，parent = -1。

最后我们可以总结一下：

  • 当subRL = 0时：调整为subRL = 0，subR = 0，parent = 0。
  • 当subRL = -1时：调整为subRL = 0，subR = 1，parent = 0。
  • 当subRL = 1时：调整为subRL = 0，subL = 0，parent = -1。
void RotateRL(Node*&parent)
{
    //提前记录关键节点，防止旋转之后找不到
	Node* cur = parent;
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	int bf = subRL->_bf;
	//先右单旋
	RotateR(parent->_right);
	//再左单旋
	RotateL(parent);
	//1.情况一
	if (bf == 0)
	{
		cur->_bf = subRL->_bf = subR->_bf = 0;
	}
	//2.情况二
	else if (bf == -1)
	{
		cur->_bf = 0;
		subR->_bf = 1;
		subRL->_bf = 0;
	}
	//3.情况三
	else if (bf == 1)
	{
		cur->_bf = -1;
		subR->_bf = 0;
		subRL->_bf = 0;
	}
	else
	{
		//走到这里说明AVL树出错
		assert(false);
	}
}
  • 特别注意：这里需要提前记录关键节点，防止旋转时发生改变而找不到。

5.2. AVL树的插入

向AVL树进行插入，首先是先找到需要插入的位置，这个逻辑与二叉搜索树类似，这里就不在赘述。找到之后对父节点的平衡因子进行更新，更新平衡因子就可以分为以下三种大的情况：

  1. 父节点平衡因子为 0，整体高度不变，不需要再向上调整平衡因子。

img

  1. 父节点平衡因子为1或-1，整体高度改变，需要再向上调整平衡因子。

img

  1. 父节点平衡因子为2或-2，平衡被破坏，需要进行旋转。

平衡被破坏同样可以分为四种情况，与旋转的方式想对应，其中蓝色为插入节点。首先第一种往较高左子树的左侧插入，此时parent = -2，subL = -1，进行右单旋。

img

第二种往较高右子树的右侧插入，此时parent = 2，subL = 1，进行左单旋。

img

第三种往较高左子树的右侧插入，此时parent = -2，subL = 1，先左旋再右旋。

img

img

第四种往较高右子树的右侧插入，先右旋再左旋，此时parent = 2，subR = -1，先右旋再左旋。

img

img

最后我们可以归纳总结出：

  1. 父节点平衡因子为 0，整体高度不变，不需要再向上调整平衡因子。
  2. 父节点平衡因子为1或-1，整体高度改变，需要再向上调整平衡因子。
  3. 父节点平衡因子为2或-2，平衡被破坏，需要进行旋转。设父节点为parent，插入方向子节点为cur。
  • parent = -2且cur = -1进行右单旋。
  • parent = 2且cur = 1进行左单旋。
  • parent = -2且cur = 1进行先进行左单旋，再进行右单旋。
  • parent = 2且cur = -1进行先进行右单旋，再进行左单旋。
	bool insert(const pair<K, V>& kv)
	{
		// 如果根节点为空，创建新节点作为根节点并设置平衡因子为 0，然后返回插入成功
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_bf = 0;
			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->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		cur->_parent = parent;

		// 更新平衡因子
		while (parent)
		{
			// 如果插入在左边，父节点的平衡因子减 1
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			// 如果插入在右边，父节点的平衡因子加 1
			else
			{
				parent->_bf++;
			}
			// 如果父节点平衡因子为 0，整体高度不变，不需要再向上调整
			if (parent->_bf == 0)
			{
				break;
			}
			// 平衡因子为 1 或 -1，需要继续向上调整
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			// 平衡因子为 -2 或 2，需要进行旋转操作以保持平衡
			else if (parent->_bf == -2 || parent->_bf == 2)
			{
				// 右单旋
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				// 左单旋
				else if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				// 左右双旋
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				// 右左双旋
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}

				break;
			}
			// 插入之前 AVL 树就已经不平衡了，断言
			else
			{
				assert(false);
			}
		}
		return true;
    }

5.3. AVL树的查找

AVL树的查找逻辑就与二叉搜索树一样了，这里就不在赘述。

Node* Find(const K& val)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_kv.first > val)
		{
			//左子树中查找
			cur = cur->_left;
		}
		else if (cur->_kv.first < val)
		{
			//右子树中查找
			cur = cur->_right;

		}
		else
		{
			//找到了
			return cur;
		}
	}
	return nullptr;
}

5.4. AVL树的删除

AVL树的删除逻辑其实整体与二叉搜索树的删除逻辑类似，可以分为三种情况讨论：删除节点的左子树节点为空

，删除节点的右子树节点为空，删除节点的左右子树都不为空。其中删除节点的左右子树都不为空可以经过伪删除法，即寻找到左子树的最右节点即左子树的最大值，或者是右子树的最左节点即右子树的最小值。然后赋值，转换为在其左子树或者右子树删除节点。而我们的AVL树本质是为了保持平衡，所以尽量选择删除子树较高的一方。

因为删除节点的左右子树都不为空的情况一定会被转换另外两种情况，所以我们只需要讨论删除节点的左子树节点为空，删除节点的右子树节点为空这两种情况。

当然这里在上面基础上再重新分类可分为：

  1. 删除节点在父节点的左侧：

当节点数少于三个时，删除后父节点平衡因子为1或0时，正常删除。

img

当父节点parent的右子树的左右子树高度相等即右子树的_bf = 0，且删除后父节点平衡因子为2时，进行左单旋。

img

特别注意：这里的左单旋比较特殊，因为这里的左单旋之后parent与subR不等于0，而是分别等于1与-1。

当父节点parent的右子树的右子树高度大于其左子树高度即右子树的_bf > 0，且删除后父节点平衡因子为2时，进行左单旋。

img

当父节点parent的右子树的右子树高度小于其左子树高度即右子树的_bf < 0，且删除后父节点平衡因子为2时，先进行右单旋，再进行左单旋。

img

  1. 删除节点在父节点右侧：

当节点数少于三个时，删除后父节点平衡因子为-1或0时，正常删除。

img

当父节点parent的左子树的左右子树高度相等即左子树的_bf = 0，且删除后父节点平衡因子为-2时，进行右单旋。

img

特别注意：这里的右单旋比较特殊，因为这里的右单旋之后parent与subL不等于0，而是分别等于-1与1。

当父节点parent的左子树的左子树高度大于其右子树高度即左子树的_bf < 0，且删除后父节点平衡因子为-2时，进行右单旋。

img

当父节点parent的左子树的左子树高度小于其右子树高度即左子树的_bf > 0，且删除后父节点平衡因子为-2时，先进行左单旋，再进行右单旋。

img

最后我们可以总结出以下结论：

  1. 当删除节点在父节点的左侧时
  • 父节点的平衡因子为2时，当根节点的右子树的右子树高度大于等于其左子树高度，即右子树的_bf>=0时，进行左单旋，否则先进行右旋再左旋。
  • 父节点的平衡因子不为2时，正常删除。
  1. 当删除节点在父节点的右侧时
  • 父节点的平衡因子为-2时，当根节点的左子树的左子树高度大于等于其右子树高度，即左子树的_bf<=0时，进行右单旋，否则先进行左旋再右旋。
  • 父节点的平衡因子不为-2时，正常删除。
//求高度
int Hegiht(Node* root)
{
    if (root == nullptr)
        return 0;
    int leftHegiht = Hegiht(root->_left);//先计算左子树高度
    int rightHegiht = Hegiht(root->_right);//再计算右子树高度
    return leftHegiht > rightHegiht ? leftHegiht + 1 : rightHegiht + 1;
}
void erase(const K& val)
{
    //递归删除
    _root = _erase(_root, val);
}
Node* _erase(Node* node, const K& val)
{
    // 如果当前节点为空，直接返回空指针
    if (node == nullptr)
    {
        return nullptr;
    }

    // 如果当前节点的键值大于要删除的键值，在左子树中删除
    if (node->_kv.first > val)
    {
        node->_left = _erase(node->_left, val);
        //更新节点的父节点
        if (node->_left)
        node->_left->_parent = node;
        // 调整节点的平衡因子
        node->_bf = Hegiht(node->_right) - Hegiht(node->_left);
        int bf = node->_bf;
        //情况一删除节点都在左边
        if (bf == 2)
        {
            //右侧的平衡因子
            int right_bf = node->_right->_bf;
            if (right_bf >= 0)
            {
                Node* subR = node->_right;
                Node* parent = node;
                RotateL(node);
                //高度相等，要重新更新平衡因子
                if (right_bf == 0)
                {
                    subR->_bf = -1;
                    parent->_bf = 1;
                }
            }
            else
            {
                RotateRL(node);
            }
        }
        
    }
    // 如果当前节点的键值小于要删除的键值，在右子树中删除
    else if (node->_kv.first < val)
    {
        node->_right = _erase(node->_right, val);
        //更新节点的父节点
        if(node->_right)
        node->_right->_parent = node;
        // 调整节点平衡因子
        node->_bf = Hegiht(node->_right) - Hegiht(node->_left);
        int bf = node->_bf;
        //情况二删除节点都在右边
        if (bf == -2)
        {
            //左侧的平衡因子
            int left_bf = node->_left->_bf;
            if (left_bf <= 0)
            {
                Node* subL = node->_left;
                Node* parent = node;
                RotateR(node);
                //高度相等，要重新更新平衡因子
                if (left_bf == 0)
                {
                    subL->_bf = 1;
                    parent->_bf = -1;
                }
            }
            else
            {
                RotateLR(node);
            }
        }
    }
    // 找到要删除的节点
    else
    {
        // 如果节点有两个孩子
        if (node->_left != nullptr && node->_right != nullptr)
        {
            // 如果左子树高度大于等于右子树高度
            if (Hegiht(node->_left) >= Hegiht(node->_right))
            {
                // 找到左子树中的最大节点
                Node* prev = node->_left;
                while (prev->_right)
                    prev = prev->_right;
                int target = prev->_kv.first;
                // 将当前节点的值替换为左子树中的最大节点的值
                node->_kv = prev->_kv;
                // 在左子树中删除该最大节点
                node->_left = _erase(node->_left,target);
                if (node->_left)
                    node->_left->_parent = node;
                // 调整节点的平衡因子
                node->_bf = Hegiht(node->_right) - Hegiht(node->_left);
            }
            else
            {
                // 找到右子树中的最小节点
                Node* post = node->_right;
                while (post->_left)
                    post = post->_left;
                // 将当前节点的值替换为右子树中的最小节点的值
                int target = post->_kv.first;
                node ->_kv = post->_kv ;
                // 在右子树中删除该最小节点
                node->_right = _erase(node->_right, target);
                if (node->_right)
                    node->_right->_parent = node;
                // 调整节点平衡因子
                node->_bf = Hegiht(node->_right) - Hegiht(node->_left);
            }
        }
        // 如果节点最多有一个孩子
        else
        {
            // 如果有左孩子
            if (node->_left != nullptr)
            {
                // 保存左孩子指针
                Node* left = node->_left;
                // 删除当前节点
                delete node;
                // 返回左孩子指针
                return left;
            }
            // 如果有右孩子
            else if (node->_right != nullptr)
            {
                // 保存右孩子指针
                Node* right = node->_right;
                // 删除当前节点
                delete node;
                // 返回右孩子指针
                return right;
            }
            // 如果没有孩子
            else
            {
                // 返回空指针
                delete node;
                return nullptr;
            }
        }
    }
    // 返回调整后的节点指针
    return node;
}

6. 判断是否为AVL树

在判断一棵树是否为 AVL 树时，首先判断是否为二叉搜索树。

然后再检查每一个节点的左右子树高度差的绝对值是否小于 1 。由于需要对整棵树的所有子树进行这样的判断，所以采用递归的方法比较合适的。

具体实现时，定义一个函数来进行判断。然后，分别递归地获取左子树和右子树的高度。接着，进行条件判断。如果左子树或右子树中存在高度标记为 -1 的情况（意味着该子树不平衡），或者当前节点左右子树高度差的绝对值大于 1 ，那么就将当前子树的高度标记为 -1 并返回。如果当前节点的子树都是平衡的，那么就返回最高的高度。

最后，通过一个总函数来调用这个递归函数，并根据返回结果是否大于 0 来确定整棵树是否为 AVL 树。如果大于 0 ，则表示整棵树是AVL 树；否则，表示不是AVL树。

//判断是否平衡
bool isBalanced()
{
    return _isBalanced(_root) >= 0 && isValidBST();
}
bool isValidBST()
{
    return _isValidBST(_root, LONG_MIN, LONG_MAX);
}
bool _isValidBST(Node* root, long long lower, long long upper)
{
    if (root == nullptr)
    {
        return true;
    }
    if (root->_kv.first <= lower || root->_kv.first >= upper)
    {
        return false;
    }
    bool left = _isValidBST(root->_left, lower, root->_kv.first);
    bool right = _isValidBST(root->_right, root->_kv.first, upper);
    return left && right;
}
int _isBalanced(Node* root)
{
	if (root == nullptr)
	{
		return 0;
	}
	//左平衡高度
	int left_isBalanced = _isBalanced(root->_left);
	//右平衡高度
	int right_isBalanced = _isBalanced(root->_right);
	//如果右平衡-左平衡则返回-1，并且防止两边同时返回-1相减等于0的情况，需要单独判断
	if (left_isBalanced == -1 || right_isBalanced == -1 || abs(right_isBalanced - left_isBalanced) > 1)
	{
		return -1;
	}
	//返回最高高度
	return max(left_isBalanced, right_isBalanced) + 1;
}

7.复杂度分析

下是对上述AVL 树代码中主要操作的时间复杂度和空间复杂度分析：

时间复杂度：

  • insert 操作：平均和最坏情况下的时间复杂度均为 O ( log ⁡ n ) O(\log n) O(logn)。在插入过程中，通过不断调整平衡因子和进行旋转操作来保持树的平衡，每次调整和旋转的操作时间都是常数级，而查找插入位置的过程类似于二叉搜索树，时间复杂度为
    O ( log ⁡ n ) O(\log n) O(logn)。
  • Find 操作：平均和最坏情况下的时间复杂度均为 O ( log ⁡ n ) O(\log n) O(logn)。与二叉搜索树的查找过程类似，每次比较都将搜索范围缩小一半。
  • erase 操作：平均和最坏情况下的时间复杂度均为 O ( log ⁡ n ) O(\log n) O(logn)。删除节点时需要查找节点位置，然后进行调整和可能的旋转操作，时间复杂度类似于插入操作。

空间复杂度：

  • insert 操作：空间复杂度为 O ( 1 ) O(1) O(1)。在插入过程中，主要的额外空间消耗在于创建新节点以及一些临时变量来存储指针和平衡因子等信息，这些都是常数级的空间消耗。
  • Find 操作：空间复杂度为 O ( 1 ) O(1) O(1)。在查找过程中，仅使用了一些固定数量的指针和临时变量，没有额外的大规模空间分配。
  • erase 操作：空间复杂度为 O ( 1 ) O(1) O(1)。删除操作中，主要的空间消耗在于临时变量和指针的存储，没有动态分配大规模的额外空间。

总的来说，上述各个操作的主要空间复杂度都为 O ( 1 ) O(1) O(1)，整个 AVL 树的空间复杂度主要取决于树中节点的数量，即 O ( n ) O(n) O(n)，其中
n n n 是节点的数量。

8. 源码

#pragma once
#include<utility>
#include<assert.h>
template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode(const pair<K, V>& val = pair<K, V>())
		:_kv(val)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_bf(0)
	{}
	pair<K, V> _kv;//kv模型
	int _bf;//平衡因子
	AVLTreeNode* _left;//左子树
	AVLTreeNode* _right;//右子树
	AVLTreeNode* _parent;//指向父节点
};
template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	//...具体功能
	AVLTree()
	{}
	AVLTree(const AVLTree& t)
	{
		_root = copy(t._root);
	}
	AVLTree<K,V>& operator=(const AVLTree <K,V> t)
	{
		//赋值重载
		this->swap(_root, t._root);
		return *this;
	}
	void RotateR(Node*&parent)
	{
		// 获取父节点的左子节点
		Node* subL = parent->_left;
		// 获取父节点左子节点的右子节点
		Node* subLR = subL->_right;

		// 1.将subLR链接到parent的左边。
		parent->_left = subLR;
		// 如果父节点左子节点的右子节点存在，设置其父节点为当前父节点
		if (subLR)
		{
			subLR->_parent = parent;
		}
		// 获取父节点的父节点
		Node* ppNode = parent->_parent;
		// 2.将parent链接到subL的右边。
		subL->_right = parent;
		//parent的父节点指向subL
		parent->_parent = subL;
		// 如果父节点存在父节点
		if (ppNode)
		{
			// 如果父节点是其父亲节点的左子节点
			if (ppNode->_left == parent)
			{
				// 将父节点的父亲节点的左子节点设置为当前父节点的左子节点
				ppNode->_left = subL;
			}
			// 如果父节点是其父亲节点的右子节点
			else
			{
				// 将父节点的父亲节点的右子节点设置为当前父节点的左子节点
				ppNode->_right = subL;
			}
			// 设置父节点左子节点的父节点为父节点的父节点
			subL->_parent = ppNode;
		}
		// 如果父节点为根节点
		else
		{
			// 将根节点设置为父节点的左子节点
			_root = subL;
			// 将父节点左子节点的父节点设置为空
			subL->_parent = nullptr;
		}
		//3.将parent与subL的平衡因子置为0。
		subL->_bf = parent->_bf = 0;
		//改变parent节点的指向，方便erase中的node返回
		parent = subL;
	}
	void RotateL(Node* &parent)
	{
		// 获取父节点的右子节点
		Node* subR = parent->_right;
		// 获取父节点右子节点的左子节点
		Node* subRL = subR->_left;
		//1.将subRL链接到parent的右边。
		parent->_right = subRL;
		// 如果父节点右子节点的左子节点存在，设置其父节点为当前父节点
		if (subRL)
		{
			subRL->_parent = parent;
		}
		// 获取父节点的父节点
		Node* ppNode = parent->_parent;
		//2.将parent链接到subR的左边。
		subR->_left = parent;
		// 设置父节点的父节点为右子节点
		parent->_parent = subR;

		// 如果父节点存在父节点
		if (ppNode)
		{
			// 如果父节点是其父亲节点的左子节点
			if (ppNode->_left == parent)
			{
				// 将父节点的父亲节点的左子节点设置为当前父节点的右子节点
				ppNode->_left = subR;
			}
			// 如果父节点是其父亲节点的右子节点
			else
			{
				// 将父节点的父亲节点的右子节点设置为当前父节点的右子节点
				ppNode->_right = subR;
			}
			// 设置父节点右子节点的父节点为父节点的父节点
			subR->_parent = ppNode;
		}
		// 如果父节点为根节点
		else
		{
			// 将根节点设置为父节点的右子节点
			_root = subR;
			// 将父节点右子节点的父节点设置为空
			subR->_parent = nullptr;
		}
		// 3.将parent与subR的平衡因子置为0。
		subR->_bf = parent->_bf = 0;
		//改变parent节点的指向，方便erase中的node返回
		parent = subR;
	}
	void RotateLR(Node*&parent)
	{
		//提前记录关键节点，防止旋转之后找不到
		Node* cur = parent;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;
		//先左旋
		RotateL(parent->_left);
		//再右旋
		RotateR(parent);
		//1.情况1
		if (bf == 0)
		{
			cur->_bf = subL->_bf = subLR->_bf = 0;
		}
		//2.情况2
		else if (bf == -1)
		{
			cur->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		//3.情况3
		else if (bf == 1)
		{
			cur->_bf = 0;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		else
		{
			//走到这里说明AVL树有问题
			assert(false);
		}
	}
	
	void RotateRL(Node*&parent)
	{
		//提前记录关键节点，防止旋转之后找不到
		Node* cur = parent;
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;
		//先右单旋
		RotateR(parent->_right);
		//再左单旋
		RotateL(parent);
		//1.情况一
		if (bf == 0)
		{
			cur->_bf = subRL->_bf = subR->_bf = 0;
		}
		//2.情况二
		else if (bf == -1)
		{
			cur->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		//3.情况三
		else if (bf == 1)
		{
			cur->_bf = -1;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			//走到这里说明AVL树出错
			assert(false);
		}
	}
	bool insert(const pair<K, V>& kv)
	{
		// 如果根节点为空，创建新节点作为根节点并设置平衡因子为 0，然后返回插入成功
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_bf = 0;
			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->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		cur->_parent = parent;

		// 更新平衡因子
		while (parent)
		{
			// 如果插入在左边，父节点的平衡因子减 1
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			// 如果插入在右边，父节点的平衡因子加 1
			else
			{
				parent->_bf++;
			}
			// 如果父节点平衡因子为 0，整体高度不变，不需要再向上调整
			if (parent->_bf == 0)
			{
				break;
			}
			// 平衡因子为 1 或 -1，需要继续向上调整
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			// 平衡因子为 -2 或 2，需要进行旋转操作以保持平衡
			else if (parent->_bf == -2 || parent->_bf == 2)
			{
				// 右单旋
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				// 左单旋
				else if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				// 左右双旋
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				// 右左双旋
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}

				break;
			}
			// 插入之前 AVL 树就已经不平衡了，断言
			else
			{
				assert(false);
			}
		}

		return true;
    }
	Node* Find(const K& val)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first > val)
			{
				//左子树中查找
				cur = cur->_left;
			}
			else if (cur->_kv.first < val)
			{
				//右子树中查找
				cur = cur->_right;

			}
			else
			{
				//找到了
				return cur;
			}
		}
		return nullptr;
	}
	//求高度
	int Hegiht(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHegiht = Hegiht(root->_left);//先计算左子树高度
		int rightHegiht = Hegiht(root->_right);//再计算右子树高度

		return leftHegiht > rightHegiht ? leftHegiht + 1 : rightHegiht + 1;
	}
	void erase(const K& val)
	{
		//递归删除
		_root = _erase(_root, val);
	}
	//判断是否平衡
	bool isBalanced()
	{
		return _isBalanced(_root) >= 0;
	}
	~AVLTree()
	{
		Destroy(_root);
	}

private:
	void Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		//cout << root->_kv.first << " ";
		//递归销毁左子树
		Destroy(root->_left);
		//递归销毁右子树
		Destroy(root->_right);
		//销毁根节点
		delete root;
		//root = nullptr;
	}
	Node* _erase(Node* node, const K& val)
	{
		// 如果当前节点为空，直接返回空指针
		if (node == nullptr)
		{
			return nullptr;
		}

		// 如果当前节点的键值大于要删除的键值，在左子树中删除
		if (node->_kv.first > val)
		{
			node->_left = _erase(node->_left, val);
			//更新节点的父节点
			if (node->_left)
			node->_left->_parent = node;
			// 调整节点的平衡因子
			node->_bf = Hegiht(node->_right) - Hegiht(node->_left);
			int bf = node->_bf;
			//情况一删除节点都在左边
			if (bf == 2)
			{
				//右侧的平衡因子
				int right_bf = node->_right->_bf;
				if (right_bf >= 0)
				{
					Node* subR = node->_right;
					Node* parent = node;
					RotateL(node);
					//高度相等，要重新更新平衡因子
					if (right_bf == 0)
					{
						subR->_bf = -1;
						parent->_bf = 1;
					}
				}
				else
				{
					RotateRL(node);
				}
			}
			
		}
		// 如果当前节点的键值小于要删除的键值，在右子树中删除
		else if (node->_kv.first < val)
		{
			node->_right = _erase(node->_right, val);
			//更新节点的父节点
			if(node->_right)
			node->_right->_parent = node;
			// 调整节点平衡因子
			node->_bf = Hegiht(node->_right) - Hegiht(node->_left);
			int bf = node->_bf;
			//情况二删除节点都在右边
			if (bf == -2)
			{
				//左侧的平衡因子
				int left_bf = node->_left->_bf;
				if (left_bf <= 0)
				{
					Node* subL = node->_left;
					Node* parent = node;
					RotateR(node);
					//高度相等，要重新更新平衡因子
					if (left_bf == 0)
					{
						subL->_bf = 1;
						parent->_bf = -1;
					}
				}
				else
				{
					RotateLR(node);
				}
			}
		}
		// 找到要删除的节点
		else
		{
			// 如果节点有两个孩子
			if (node->_left != nullptr && node->_right != nullptr)
			{
				// 如果左子树高度大于等于右子树高度
				if (Hegiht(node->_left) >= Hegiht(node->_right))
				{
					// 找到左子树中的最大节点
					Node* prev = node->_left;
					while (prev->_right)
						prev = prev->_right;
					int target = prev->_kv.first;
					// 将当前节点的值替换为左子树中的最大节点的值
					node->_kv = prev->_kv;
					// 在左子树中删除该最大节点
					node->_left = _erase(node->_left,target);
					if (node->_left)
						node->_left->_parent = node;
					// 调整节点的平衡因子
					node->_bf = Hegiht(node->_right) - Hegiht(node->_left);
				}
				else
				{
					// 找到右子树中的最小节点
					Node* post = node->_right;
					while (post->_left)
						post = post->_left;
					// 将当前节点的值替换为右子树中的最小节点的值
					int target = post->_kv.first;
					node ->_kv = post->_kv ;
					// 在右子树中删除该最小节点
					node->_right = _erase(node->_right, target);
					if (node->_right)
						node->_right->_parent = node;
					// 调整节点平衡因子
					node->_bf = Hegiht(node->_right) - Hegiht(node->_left);

				}
			}
			// 如果节点最多有一个孩子
			else
			{
				// 如果有左孩子
				if (node->_left != nullptr)
				{
					// 保存左孩子指针
					Node* left = node->_left;
					// 删除当前节点
					delete node;
					// 返回左孩子指针
					return left;
				}
				// 如果有右孩子
				else if (node->_right != nullptr)
				{
					// 保存右孩子指针
					Node* right = node->_right;
					// 删除当前节点
					delete node;
					// 返回右孩子指针
					return right;
				}
				// 如果没有孩子
				else
				{
					// 返回空指针
					delete node;
					return nullptr;
				}
			}
		}
		// 返回调整后的节点指针
		return node;
	}
	int _isBalanced(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		//左平衡高度
		int left_isBalanced = _isBalanced(root->_left);
		//右平衡高度
		int right_isBalanced = _isBalanced(root->_right);
		//如果右平衡-左平衡则返回-1，并且防止两边同时返回-1相减等于0的情况，需要单独判断
		if (left_isBalanced == -1 || right_isBalanced == -1 || abs(right_isBalanced - left_isBalanced) > 1)
		{
			return -1;
		}
		//返回最高高度
		return max(left_isBalanced, right_isBalanced) + 1;
	}
	Node* copy(Node* root)
	{
		// 如果传入的根节点为空，直接返回空指针，表示拷贝结束
		if (root == nullptr)
			return nullptr;
		// 为新树创建一个与原始根节点值相同的新节点
		Node* newnode = new Node(root->_kv);
		// 递归地拷贝原始根节点的左子树，并将结果赋给新节点的左指针
		newnode->_left = copy(root->_left);
		// 递归地拷贝原始根节点的右子树，并将结果赋给新节点的右指针
		newnode->_right = copy(root->_right);
		// 新节点的父节点默认为空
		newnode->_parent = nullptr;
		// 如果新节点的左子节点存在，设置其父节点为新节点
		if (newnode->_left)
		{
			newnode->_left->_parent = newnode;
		}
		// 如果新节点的右子节点存在，设置其父节点为新节点
		if (newnode->_right)
		{
			newnode->_right->_parent = newnode;
		}
		// 返回新树的根节点指针
		return newnode;
	}
	Node* _root = nullptr;//根节点
};
Betty’s Sweet
关注
专栏目录
持久化数据结构：从理论到实践，深入解析不可变集合的实现与优化
一键难忘的博客
09-20 2129
只能访问数据结构的最新版本。可以访问数据结构的任意历史版本。在持久化数据结构中，每次更新操作都会生成一个新的版本，这些版本通过某种方式共享内存，以最大限度地减少空间消耗。这种特性使得持久化数据结构在需要频繁回溯历史状态的应用场景中非常有用，比如撤销操作、时间旅行调试等。
探索数据结构：红黑树的分析与实现
Bettysweetyaaa的博客
08-19 1474
本文全面介绍红黑树，从引入背景讲起，涵盖特点、功能、结构、初始化与销毁、功能实现、删除操作、判断方法及复杂度分析。其解决 AVL 树插入低效问题，节点有颜色，功能常见，结构类似二叉搜索树，操作复杂，判断需多条件。
探索数据结构：跳表的分析与实现
Bettysweetyaaa的博客
08-25 1130
想了解一种高效的数据结构吗？本文为你介绍跳表！它在有序链表基础上增加“跳跃”功能，通过随机函数设计和巧妙的实现，具有优秀的查找、插入和删除效率。与平衡搜索树和哈希表相比，跳表有独特优势。快来一探究竟吧！
【高阶数据结构】二叉树进阶探秘：AVL树的平衡机制与实现详解
大一在读，博客主要分享C/C++方向相关的内容，欢迎关注我的博主，希望可以跟各位大佬深入学习！
10-07 2684
大家好，这里是店小二！今天我们将深入探讨高阶数据结构中的AVL树。AVL树是一种自平衡的二叉搜索树，可以看作是对传统二叉搜索树的优化版本。如果你对数据结构感兴趣，快拿出你的小本本，和我们一起开始这段探索之旅吧！
深入探索数据结构技术：理论、实践与应用
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
04-16 3万+
数据结构技术的学习是一个逐步深入的过程，需要理论与实践相结合，不断通过编程练习巩固所学知识。只有扎实掌握数据结构，才能在面对复杂数据处理问题时游刃有余，为软件开发、数据分析、算法设计等领域的专业发展打下坚实基础。希望通过本文的引导，读者能够系统地学习并掌握数据结构技术，不断提升自身的编程素养与问题解决能力。
从零开始学习数据结构与算法：Python实现
一键难忘的博客
03-17 3244
数据结构与算法是计算机科学中至关重要的概念之一，对于任何想要成为优秀程序员的人来说，深入理解它们是必不可少的。本文将介绍如何从零开始学习数据结构与算法，并使用Python语言实现一些基本的数据结构和算法，帮助读者入门。
探索数据结构：从基础到高级
努力是为了站在万人之中，成为别人的光
09-14 7512
数据结构是计算机科学和编程中的基础概念，它们用于组织和存储数据以便有效地进行操作和管理。本文将带您深入探讨数据结构，从基础的数组和链表到高级的树和图，以及它们在实际编程中的应用。
【高阶数据结构】深度探索二叉树进阶：二叉搜索树概念及其高效实现
大一在读，博客主要分享C/C++方向相关的内容，欢迎关注我的博主，希望可以跟各位大佬深入学习！
10-03 1687
本章是高阶数据结构笔记的第一篇文章，将分享二叉搜索树的进阶概念及其高效实现的相关知识，欢迎大家阅读！
探索高效数据结构：data.avl 开源项目推荐
gitblog_00348的博客
09-08 709
探索高效数据结构：data.avl 开源项目推荐 data.avlPersistent sorted maps and sets with log-time rank queries项目地址:https://gitcode.com/gh_mirrors/da/data.avl 在现代软件开发中，高效的数据结构是提升系统性能的关键。今天，我们将介绍一个强大的开源项目——data.avl，它为Clo...
高级数据结构探索：红黑树与AVL树
常见的数据结构包括数组、链表、栈、队列、树、图等。 ## 1.2 数据结构的分类 数据结构可以分为线性结构和非线性结构，线性结构包括数组、链表、栈、队列等；非线性结构包括树、图等。另外，数据结构还可以按照...
Java数据结构与算法复习：AVL树、红黑树与平衡化技术
[Java数据结构与算法复习：AVL树、红黑树与平衡化技术](https://img-blog.csdnimg.cn/20210110214018338.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0...
高级数据结构：红黑树与B树的比较分析，数据结构的终极选择
[高级数据结构：红黑树与B树的比较分析，数据结构的终极选择](https://img-blog.csdnimg.cn/20190330162155683.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG...
二叉查找树/AVL树/红黑树/B树/B+树概念扫盲大法-数据结构与算法小结3（升级版）
StefanSSSS的博客
11-04 334
本期来一期对各类树的概念扫盲，建立对主流的几种树的基本的认识； 本篇的核心主线为：如何更快的操作（增删改查）一条数据？能不能更快？再快，如何最快？看到最后，你如果理解了为什么下面的各类树结构会越来越快的话，基本就掌握到窍门了，可以投身实战了；（本篇阅读需要耐心慢慢看） 本期脑图： 在没有了解这些数据结构之前，我们想要查找一个数据通过什么方式？ 遍历：就是一个一个找，想不想更快？二叉查找树满足你！ 1.二叉查找树： 二叉查找树（Binary Search T...
【Java数据结构】二叉树
2401_83227065的博客
10-13 910
1.2.3.4.
408 10——42题
最新发布
2402_85676269的博客
10-14 626
设将n(n>1)个整数存放到一维数组R中。试设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移p(0<p<n)个位置，即将R中的数据由 口X00X1...Xn-1口变换为口Xp口Xp+1...Xn-10X00X1...Xp-1口。要求:(1)给出算法的基本设计思想。(2)根据设计思想，采用C或C++或JAVA语言描述算法，关键之处给出注释，(3)说明你所设计算法的时间复杂度和空间复杂度。
数据结构：用双栈实现一个队列
AWSDN的博客
10-11 273
本文主要介绍如何用双栈实现一个队列
数据结构：使用双队列实现一个栈
AWSDN的博客
10-11 250
本文主要介绍如何用双队列实现一个栈
浙大数据结构：09-排序1 排序
qq_74924951的博客
10-11 308
多种排序算法总结
【数据结构-栈】力扣155. 最小栈
sjsjs11的博客
10-11 309
由于是栈是先进后出的原则，每次push的时候，我们要把元素push到x_stack中，然后将最小栈的栈顶元素和当前元素比较，push最小的元素，所以最小栈的栈顶始终是x_stack中的最小元素。：对于题目中的所有操作，时间复杂度均为 O(1)。因为栈的插入、删除与读取操作都是 O(1)，我们定义的每个操作最多调用栈操作两次。最坏情况下，我们会连续插入 n 个元素，此时两个栈占用的空间为 O(n)。设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。--> 返回 -3.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Betty’s Sweet

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

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

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

打赏作者

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

抵扣说明：

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

余额充值