【C++】17. AVL树实现

怀旧,2025-09-05 13:44

文章目录

一、AVL的概念

  • AVL树是最先发明的⾃平衡⼆叉查找树，AVL是⼀颗空树，或者具备下列性质的⼆叉搜索树：它的左右⼦树都是AVL树，且左右⼦树的⾼度差的绝对值不超过1。AVL树是⼀颗⾼度平衡搜索⼆叉树，通过控制⾼度差去控制平衡。

  • AVL树得名于它的发明者G.M.Adelson-Velsky和E.M.Landis是两个前苏联的科学家，他们在1962年的论⽂《An algorithm for the organization of information》中发表了它。

  • AVL树实现这⾥我们引⼊⼀个平衡因⼦(balance factor)的概念，每个结点都有⼀个平衡因⼦，任何结点的平衡因⼦等于右⼦树的⾼度减去左⼦树的⾼度，也就是说任何结点的平衡因⼦等于0/1/-1，AVL树并不是必须要平衡因⼦，但是有了平衡因⼦可以更⽅便我们去进⾏观察和控制树是否平衡，就像⼀个⻛向标⼀样。

  • 思考⼀下为什么AVL树是⾼度平衡搜索⼆叉树，要求⾼度差不超过1，⽽不是⾼度差是0呢？0不是更好的平衡吗？画画图分析我们发现，不是不想这样设计，⽽是有些情况是做不到⾼度差是0的。⽐如⼀棵树是2个结点，4个结点等情况下，⾼度差最好就是1，⽆法做到⾼度差是0。

  • AVL树整体结点数量和分布和完全⼆叉树类似，⾼度可以控制在logN ，那么增删查改的效率也可以控制在O(logN) ，相⽐⼆叉搜索树有了本质的提升。

二、AVL树的实现

1、AVL树的结构

cpp 复制代码 
template<class K, class V>
struct AVLTreeNode
{
	pair<K, V> _kv;//节点的值
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;//平衡因子

	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		_bf(0)
	{}
};

template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	//...

private:
	Node* _root = nullptr;
};

2、AVL树的插⼊

1）AVL树的插⼊过程

  1. 插⼊⼀个值按⼆叉搜索树规则进⾏插⼊。
  2. 新增结点以后，只会影响祖先结点的⾼度，也就是可能会影响部分祖先结点的平衡因⼦，所以更新从新增结点->根结点路径上的平衡因⼦，实际中最坏情况下要更新到根，有些情况更新到中间就可以停⽌了，具体情况我们下⾯再详细分析。
  3. 更新平衡因⼦过程中没有出现问题，则插⼊结束。
  4. 更新平衡因⼦过程中出现不平衡，对不平衡⼦树旋转，旋转后本质调平衡的同时，本质降低了⼦树的⾼度，不会再影响上⼀层，所以插⼊结束。

2）平衡因⼦更新

更新原则：

  • 平衡因⼦ = 右⼦树⾼度-左⼦树⾼度。
  • 只有⼦树⾼度变化才会影响当前结点平衡因⼦。
  • 插⼊结点，会增加⾼度，所以新增结点在parent的右⼦树，parent的平衡因⼦++，新增结点在parent的左⼦树，parent平衡因⼦- -。
  • parent所在⼦树的⾼度是否变化决定了是否会继续往上更新。

更新停⽌条件：

  • 更新后parent的平衡因⼦等于0，说明parent的平衡因⼦变化为-1->0或者1->0，更新前parent⼦树⼀边⾼⼀边低，新增的结点插⼊在低的那边，插⼊后parent所在的⼦树⾼度不变，不会影响parent的⽗亲结点的平衡因⼦，更新结束。

  • 更新后parent的平衡因⼦等于1或-1，说明parent的平衡因⼦变化为0->1或者0->-1，更新前parent⼦树两边⼀样⾼，新增的插⼊结点后，parent所在的⼦树⼀边⾼⼀边低，parent所在的⼦树符合平衡要求，但是⾼度增加了1，会影响parent的⽗亲结点的平衡因⼦，所以要继续向上更新。

  • 更新后parent的平衡因⼦等于2或-2，说明parent的平衡因⼦变化为1->2或者-1->-2，更新前parent⼦树⼀边⾼⼀边低，新增的插⼊结点在⾼的那边，parent所在的⼦树⾼的那边更⾼了，破坏了平衡，parent所在的⼦树不符合平衡要求，需要旋转处理，旋转的⽬标有两个：1、把parent⼦树旋转平衡。2、降低parent⼦树的⾼度，恢复到插⼊结点以前的⾼度。所以旋转后也不需要继续往上更新，插⼊结束。

  • 不断更新，更新到根，根的平衡因⼦是1或-1也停⽌了。

更新到10结点，平衡因⼦为2，10所在的⼦树已经不平衡，需要旋转处理

更新到中间结点，3为根的⼦树⾼度不变，不会影响上⼀层，更新结束

最坏更新到根停⽌

3）AVL树插入的代码实现

cpp 复制代码 
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 (cur->_kv.first < kv.first)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_kv.first > kv.first)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}

	//插入到空位
	cur = new Node(kv);

	//确定插入位置并向下连接
	if (parent->_kv.first < kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = 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)
		{
			//旋转

			break;
		}
		else
		{
			assert(false);
		}
	}

	return true;
}

3、旋转

1）旋转的原则

  1. 保持搜索树的规则。
  2. 让旋转的树从不满⾜变平衡，其次降低旋转树的⾼度。

旋转总共分为四种，左单旋/右单旋/左右双旋/右左双旋。

2）右单旋

  • 下图展⽰的是10为根的树，有a/b/c抽象为三棵⾼度为h的⼦树(h>=0)，a/b/c均符合AVL树的要求。10可能是整棵树的根，也可能是⼀个整棵树中局部的⼦树的根。这⾥a/b/c是⾼度为h的⼦树，是⼀种概括抽象表⽰，他代表了所有右单旋的场景，实际右单旋形态有很多种。

  • 在a⼦树中插⼊⼀个新结点，导致a⼦树的⾼度从h变成h+1，不断向上更新平衡因⼦，导致10的平衡因⼦从-1变成-2，10为根的树左右⾼度差超过1，违反平衡规则。10为根的树左边太⾼了，需要往右边旋转，控制两棵树的平衡。

  • 旋转核⼼步骤： 因为5 < b⼦树的值 < 10，将b变成10的左⼦树，10变成5的右⼦树，5变成这棵树新的根，符合搜索树的规则，控制了平衡，同时这棵的⾼度恢复到了插⼊之前的h+2，符合旋转原则。如果插⼊之前10是整棵树的⼀个局部⼦树，旋转后不会再影响上⼀层，插⼊结束了。

cpp 复制代码 
void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	Node* pParent = parent->_parent;

	parent->_left = subLR;
	if (subLR)//不能解引用空指针
	{
		subLR->_parent = parent;
	}

	subL->_right = parent;
	parent->_parent = subL;
	
	//更新根节点
	//如果原parent是根节点，不存在父节点
	if (pParent == nullptr)
	{
		_root = subL;
		subL->_parent = nullptr;
	}
	else
	{
		//原parent在父节点的左边
		if (pParent->_left == parent)
		{
			pParent->_left = subL;
		}
		else
		{
			pParent->_right = subL;
		}

		subL->_parent = pParent;
	}

	//更新平衡因子
	subL->_bf = 0;
	parent->_bf = 0;
}

3）左单旋

  • 下图展⽰的是10为根的树，有a/b/c抽象为三棵⾼度为h的⼦树(h>=0)，a/b/c均符合AVL树的要求。10可能是整棵树的根，也可能是⼀个整棵树中局部的⼦树的根。这⾥a/b/c是⾼度为h的⼦树，是⼀种概括抽象表⽰，他代表了所有左单旋的场景，实际左单旋形态有很多种，具体跟上⾯右旋类似。

  • 在a⼦树中插⼊⼀个新结点，导致a⼦树的⾼度从h变成h+1，不断向上更新平衡因⼦，导致10的平衡因⼦从1变成2，10为根的树左右⾼度差超过1，违反平衡规则。10为根的树右边太⾼了，需要往左边旋转，控制两棵树的平衡。

  • 旋转核⼼步骤： 因为10 < b⼦树的值 < 15，将b变成10的右⼦树，10变成15的左⼦树，15变成这棵树新的根，符合搜索树的规则，控制了平衡，同时这棵的⾼度恢复到了插⼊之前的h+2，符合旋转原则。如果插⼊之前10是整棵树的⼀个局部⼦树，旋转后不会再影响上⼀层，插⼊结束了。

cpp 复制代码 
void RotateL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	Node* pParent = parent->_parent;

	parent->_right = subRL;
	if (subRL)
		subRL->_parent = parent;

	subR->_left = parent;
	parent->_parent = subR;

	if (pParent == nullptr)
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else
	{
		if (pParent->_left == parent)
		{
			pParent->_left = subR;
		}
		else
		{
			pParent->_right = subR;
		}

		subR->_parent = pParent;
	}

	//更新平衡因子
	subR->_bf = 0;
	parent->_bf = 0;
}

4）左右双旋

下图中如果在b子树中插入节点，只经过一次旋转是无法达到平衡的效果的，此时就需要进行两次旋转。同时由于在b⼦树中新增结点的位置不同，平衡因⼦更新的细节也不同，通过观察8的平衡因⼦不同，从而分为三种情况：

  • 场景1：h>=1时，新增结点插⼊在e⼦树，e⼦树⾼度从h-1并为h并不断更新8->5->10平衡因⼦，引发旋转： 先以5为旋转点进行左单旋，再以10为旋转点进行右单旋，最后e变成5的右边，f变成10的左边。其中8的平衡因⼦为-1，旋转后8和5平衡因⼦为0，10平衡因⼦为1。

  • 场景2：h>=1时，新增结点插⼊在f⼦树，f⼦树⾼度从h-1变为h并不断更新8->5->10平衡因⼦，引发旋转：先以5为旋转点进行左单旋，再以10为旋转点进行右单旋，最后e变成5的右边，f变成10的左边。其中8的平衡因⼦为1，旋转后8和10平衡因⼦为0，5平衡因⼦为-1。

  • 场景3：h==0时，a/b/c都是空树，b⾃⼰就是⼀个新增结点，不断更新5->10平衡因⼦，引发旋转：先以5为旋转点进行左单旋，再以10为旋转点进行右单旋，最后e变成5的右边，f变成10的左边。其中8的平衡因⼦为0，旋转后8和10和5平衡因⼦均为0。

cpp 复制代码 
void RotateLR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;

	//提前记录subLR的平衡因子
	int bf = subLR->_bf;

	RotateL(parent->_left);
	RotateR(parent);

	//更新平衡因子
	if (bf == -1)
	{
		subLR->_bf = 0;
		subL->_bf = 0;
		parent->_bf = 1;
	}
	else if (bf == 1)
	{
		subLR->_bf = 0;
		subL->_bf = -1;
		parent->_bf = 0;
	}
	else if (bf == 0)
	{
		subLR->_bf = 0;
		subL->_bf = 0;
		parent->_bf = 0;
	}
	else
	{
		assert(false);
	}
}

5）右左双旋

跟左右双旋类似，下图中如果在b子树中插入节点，只经过一次旋转是无法达到平衡的效果的，此时就需要进行两次旋转。同时由于在b⼦树中新增结点的位置不同，平衡因⼦更新的细节也不同，通过观察12的平衡因⼦不同，从而分为三种情况：

  • 场景1：h>=1时，新增结点插⼊在e⼦树，e⼦树⾼度从h-1变为h并不断更新12->15->10平衡因⼦，引发旋转： 先以15为旋转点进行右单旋，再以10为旋转点进行左单旋，e变成10的右边，f变成15的左边。其中12的平衡因⼦为-1，旋转后10和12平衡因⼦为0，15平衡因⼦为1。

  • 场景2：h>=1时，新增结点插⼊在f⼦树，f⼦树⾼度从h-1变为h并不断更新12->15->10平衡因⼦，引发旋转。其中12的平衡因⼦为1，旋转后15和12平衡因⼦为0，10平衡因⼦为-1。

  • 场景3：h==0时，a/b/c都是空树，b⾃⼰就是⼀个新增结点，不断更新15->10平衡因⼦，引发旋转。其中12的平衡因⼦为0，旋转后10和12和15平衡因⼦均为0。

cpp 复制代码 
void RotateRL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;

	int bf = subRL->_bf;

	RotateR(parent->_right);
	RotateL(parent);

	if (bf == -1)
	{
		subRL->_bf = 0;
		subR->_bf = 1;
		parent->_bf = 0;
	}
	else if (bf == 1)
	{
		subRL->_bf = 0;
		subR->_bf = 0;
		parent->_bf = -1;
	}
	else if (bf == 0)
	{
		subRL->_bf = 0;
		subR->_bf = 0;
		parent->_bf = 0;
	}
	else
	{
		assert(false);
	}
}

4、AVL树的查找

按⼆叉搜索树逻辑实现即可，搜索效率为O(logN)。

cpp 复制代码 
Node* Find(const K& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_kv.first < key)
		{
			cur = cur->_right;
		}
		else if (cur->_kv.first > key)
		{
			cur = cur->_left;
		}
		else
		{
			return cur;
		}
	}

	return nullptr;
}

5、AVL树的平衡检测

我们实现的AVL树是否合格，我们通过检查左右⼦树⾼度差的的程序进⾏反向验证，同时检查⼀下结点的平衡因⼦更新是否出现了问题。

cpp 复制代码 
int _Height(Node* root)
{
	if (root == nullptr)
	{
		return 0;
	}

	int leftHeight = _Height(root->_left);
	int rightHeight = _Height(root->_right);
	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

bool _IsBalanceTree(Node* root)
{
	//空树也是AVL树
	if (root == nullptr)
	{
		return true;
	}

	//计算pRoot节点的平衡因子:pRoot右左子树的高度差
	int leftHeight = _Height(root->_left);
	int rightHeight = _Height(root->_right);
	int diff = rightHeight - leftHeight;


	// 如果计算出的平衡因子与pRoot的平衡因子不相等，
	// 或者pRoot平衡因子的绝对值超过2，则一定不是AVL树
	if (abs(diff) >= 2)
	{
		cout << root->_kv.first << "高度差异常" << endl;
		return false;
	}

	if (root->_bf != diff)
	{
		cout << root->_kv.first << "平衡因子异常" << endl;
		return false;
	}

	// pRoot的左和右如果都是AVL树，则该树一定是AVL树
	return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
}

6、AVL树实现的完整代码

1）AVLTree.h

cpp 复制代码 
#include<iostream>
#include<assert.h>
using namespace std;

template<class K, class V>
struct AVLTreeNode
{
	pair<K, V> _kv;//节点的值
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;//平衡因子

	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_bf(0)
	{}
};

template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<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 (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		//插入到空位
		cur = new Node(kv);

		//确定插入位置并向下连接
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = 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)
				{
					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);
				}
				else
				{
					assert(false);
				}

				break;
			}
			else
			{
				assert(false);
			}
		}

		return true;
	}

	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* pParent = parent->_parent;

		parent->_left = subLR;
		if (subLR)//不能解引用空指针
		{
			subLR->_parent = parent;
		}

		subL->_right = parent;
		parent->_parent = subL;
		
		//更新根节点
		//如果原parent是根节点，不存在父节点
		if (pParent == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			//原parent在父节点的左边
			if (pParent->_left == parent)
			{
				pParent->_left = subL;
			}
			else
			{
				pParent->_right = subL;
			}

			subL->_parent = pParent;
		}

		//更新平衡因子
		subL->_bf = 0;
		parent->_bf = 0;
	}

	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* pParent = parent->_parent;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (pParent == nullptr)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (pParent->_left == parent)
			{
				pParent->_left = subR;
			}
			else
			{
				pParent->_right = subR;
			}

			subR->_parent = pParent;
		}

		//更新平衡因子
		subR->_bf = 0;
		parent->_bf = 0;
	}

	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		//提前记录subLR的平衡因子
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);

		//更新平衡因子
		if (bf == -1)
		{
			subLR->_bf = 0;
			subL->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)
		{
			subLR->_bf = 0;
			subL->_bf = -1;
			parent->_bf = 0;
		}
		else if (bf == 0)
		{
			subLR->_bf = 0;
			subL->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == -1)
		{
			subRL->_bf = 0;
			subR->_bf = 1;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subRL->_bf = 0;
			subR->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == 0)
		{
			subRL->_bf = 0;
			subR->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	int Height()
	{
		return _Height(_root);
	}

	int Size()
	{
		return _Size(_root);
	}

	bool IsBalanceTree()
	{
		return _IsBalanceTree(_root);
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

	int _Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}

		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);
		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

	int _Size(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}

		return _Size(root->_left) + _Size(root->_right) + 1;
	}

	bool _IsBalanceTree(Node* root)
	{
		//空树也是AVL树
		if (root == nullptr)
		{
			return true;
		}

		//计算pRoot节点的平衡因子:pRoot右左子树的高度差
		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);
		int diff = rightHeight - leftHeight;


		// 如果计算出的平衡因子与pRoot的平衡因子不相等，
		// 或者pRoot平衡因子的绝对值超过2，则一定不是AVL树
		if (abs(diff) >= 2)
		{
			cout << root->_kv.first << "高度差异常" << endl;
			return false;
		}

		if (root->_bf != diff)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}

		// pRoot的左和右如果都是AVL树，则该树一定是AVL树
		return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
	}

private:
	Node* _root = nullptr;
};

2）Test.cpp

在这里测试一下实现的各种方法：

cpp 复制代码 
#include"AVLTree.h"

void TestAVLTree1()
{
	AVLTree<int, int> t;
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };//常规测试用例
	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };//带有双旋场景的测试用例

	for (auto e : a)
	{
		t.insert({ e,e });
	}

	t.InOrder();
	
	cout << t.IsBalanceTree() << endl;

}

运行结果：

cpp 复制代码 
#include<vector>
#include"AVLTree.h"

void TestAVLTree2()
{
	//插入一堆随机值，测试平衡、高度和性能
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; i++)
	{
		v.push_back(rand() + i);
	}

	//插入
	size_t begin1 = clock();
	AVLTree<int, int> t;
	for (auto e : v)
	{
		t.insert(make_pair(e, e));
	}
	size_t end1 = clock();

	//查找
	size_t begin2 = clock();
	//确定的值
	//for (auto e : v)
	//{
	//	t.Find(e);
	//}
	//随机的值
	for (size_t i = 0; i < N; i++)
	{
		t.Find(rand() + i);
	}
	size_t end2 = clock();

	cout << "Insert:" << end1 - begin1 << endl;
	cout << "Find:" << end2 - begin2 << endl;
	cout << "balance:" << t.IsBalanceTree() << endl;
	cout << "Height:" << t.Height() << endl;
	cout << "Size:" << t.Size() << endl;
}

运行结果：

相关推荐
青草地溪水旁10 分钟前
设计模式(C++)详解——迭代器模式(1)
c++·设计模式·迭代器模式
你的电影很有趣11 分钟前
lesson68：JavaScript 操作 HTML 元素、属性与样式全指南
开发语言·前端·javascript
青草地溪水旁16 分钟前
设计模式(C++)详解——迭代器模式(2)
java·c++·设计模式·迭代器模式
SamsongSSS16 分钟前
《C++ Primer Plus》读书笔记 第二章 开始学习C++
c++·后端
9号达人18 分钟前
Java18 新特性详解与实践
java·后端·面试
熊猫_豆豆20 分钟前
MATLAB画出湖面波纹相遇所形成的现象
开发语言·matlab·仿真
我不是混子24 分钟前
java浮点数精度问题及解决方案
java·后端
花心蝴蝶.42 分钟前
Java 中的代理模式
java·开发语言·代理模式
风语者6661 小时前
perl踩坑系列=====正则表达式捕获
开发语言·perl
Mr_WangAndy1 小时前
C++设计模式_创建型模式_单件模式
c++·单例模式·设计模式
热门推荐
01Multisim使用教程详尽版--(2025最新版)02UV 工具安装与国内镜像源配置指南03GitHub 镜像站点0446个Nano-banana 精选提示词，持续更新中05UV安装并设置国内源06Spec-Kit 使用指南07保姆级教程：手把手教你用Dify实现完美多轮对话（附Chatflow和提示词）08VsCode远程Copilot无法使用Claude Agent问题09Linux下V2Ray安装配置指南10KGG转MP3工具|非KGM文件|解密音频