浅析AVL树

其他 2019-01-13 09:31:05 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Ferlan/article/details/86183797

文章目录

1.什么是AVL树

今天我们来讲一讲AVL树，AVL树是二叉搜索树的优化版，又称平衡二叉搜索树，高度平衡树。我们都

知道，当一棵二叉搜索树的结点一直单边插入时，这时候它的查找效率趋近于O（n），非常慢。

而AVL树的特点是：“AVL树中任何结点的两个子树的高度最大差别为1” ，这样就克服了结点单边存储

而导致查找效率低下的问题。

在这里插入图片描述

如上图，左边是AVL树，右侧为非AVL树，右子树高度减去左子树的高度(简称平衡因子)的绝对值不超

过1(-1/0/1)，而非AVL树则做不到这一点。每当新插入一个结点后，都要检查是否保持这一原则，如

果某结点的高度差绝对值超过了1，那么就要通过旋转来重新恢复AVL树。AVL树当中最需要弄清楚的

2个问题，1个就是平衡因子的控制，另一个就是学会AVL的旋转。

2.AVL树结点的定义

template<class K>
struct AVLTreeNode
{
	K _key;//节点内的值

	AVLTreeNode<K>* _left;//左子树节点
	AVLTreeNode<K>* _right;//右子树节点
	AVLTreeNode<K>* _parent;//双亲节点

	int _bf;//平衡因子

	AVLTreeNode(const K& key)
		:_left(NULL)
		, _right(NULL)
		, _parent(NULL)
		, _key(key)
		, _bf(0)
	{}
};

上面的便是AVL树的结点的结构，其实和普通的二叉搜索树也就是加入了一个平衡因子而已，但别小

看这个平衡因子，他可能在下面的学习里会让你头疼一会儿了.

3.AVL树的平衡因子

根据上面的讲解，我们直到，平衡因子的值是当前结点右子树的高度减去左子树的高度，所以计算平

衡因子前我们还要有一个计算子树高度的函数Height（），函数GetBf（）用于计算平衡因子。

size_t Height(Node* root)//计算树的高度
	{
		if (root == nullptr)
		{
			return 0;
		}

		size_t leftHeight = Height(root->_left);
		size_t rightHeight = Height(root->_right);

		return leftHeight > rightHeight ? (leftHeight + 1) : (rightHeight + 1);

	}
	void GetBf(Node *root)//计算平衡因子
	{
		if (root == nullptr)
		{
			return;
		}
		root->_bf = Height(root->_right) - Height(root->_left);
		if (abs(root->_bf) > 1)
		{
			std::cout << "节点" << root->_key << "的平衡因子有误！" << std::endl;
		}

		GetBf(root->_left);
		GetBf(root->_right);

	}

4.AVL树的插入

AVL树的插入也属于AVL树的一个重头戏，因为他糅合了二叉树的插入，AVL树的旋转，平衡因子的修

改等多个知识点。下面我们来系统的说一下AVL树的插入。

AVL树的插入分如下几个步骤

  1. 像二叉搜索树那样将数据插入到树中。

  2. 更新父结点的平衡因子，验证插入结点及其父亲结点的平衡因子是否正确，不正确则调用适当的旋

    转函数。

  3. 使用“左单旋”，“右单旋”，“左右双旋”，“右左双旋” 4种方式的一种旋转树，并更新平衡因子的值。

4.1将数据插入到树中

	//1.判断空树
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;

		}
		//2.查找位置
		Node* cur = _root;
		Node * parent = nullptr;

		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;//节点已经存在
			}
		}
		//3.插入数据
		cur = new Node(key);
		if (parent->_key > key)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}

这段没什么好说的，直接贴上代码。

4.2更新父结点平衡因子的值，并验证是否正确，不正确则选择适当的旋转方式

//4.验证平衡因子的值

		while (parent)
		{
			if (cur == parent->_left)
			{
				--(parent->_bf);
			}
			else
			{
				++(parent->_bf);
			}
			if (parent->_bf == 0)//说明之前的平衡因子值为-1或1，此时满足AVL树特性，调整结束
			{
				break;
			}
			else if (abs(parent->_bf) == 1)//说明之前的平衡因子值为0，需要向上调整。
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			else if (abs(parent->_bf) == 2)//说明已经不满足AVL树的特性，选择适当旋转方式
			{
				if ((parent->_bf == -2) && (cur->_bf == -1))//右单旋
				{
					_RotateR(parent);
				}
				if ((parent->_bf == 2) && (cur->_bf == 1))//左单旋
				{
					_RotateL(parent);
				}
				if ((parent->_bf == -2) && (cur->_bf == 1))//左右双旋
				{
					Node* subL = parent->_left;
					Node* subLR = subL->_right;
					int bf = subLR->_bf;

					_RotateL(parent->_left);
					_RotateR(parent);

					subLR->_bf = 0;
					if (bf == 1)
					{
						subL->_bf = -1;
						parent->_bf = 0;
					}
					else if (bf == -1)
					{
						parent->_bf = 1;
						subL->_bf = 0;
					}
					

				}
				if ((parent->_bf == 2) && (cur->_bf == -1))//右左双旋
				{

					Node* subR = parent->_right;
					Node* subRL = subR->_left;
					int bf = subRL->_bf;

					_RotateR(parent->_right);
					_RotateL(parent);

					subRL->_bf = 0;
					if (bf == 1)
					{
						subR->_bf = 0;
						parent->_bf = -1;
					}
					else if (bf == -1)
					{
						parent->_bf = 0;
						subR->_bf = 1;
					}
				}
				break;//调整之后一定符合AVL树特性，调整结束。
			}
			else//大于2的情况直接报错
			{
				assert(false);
			}
		}
		return true;
	}

Cur插入后，Parent的平衡因子一定需要调整，在插入之前，Parent的平衡因子分为三种情况：-1，0, 1, 分以下两种情况：

  1. 如果Cur插入Parent的左侧，只需给Parent的平衡因子-1即可

  2. 如果Cur插入到Parent的右侧，只需给Parent的平衡因子+1即可。此时：Parent的平衡因子可 能有三种情况：0，正负1， 正负2

如果Parent的平衡因子为0，说明插入之前Parent的平衡因子为正负1，插入后被调整成0，此时

满足AVL树的性质，插入成功。

如果Parent的平衡因子为正负1，说明插入前Parent的平衡因子一定为0，插入后被更新成正负1，

此时以Parent为根的树的高度增加，需要继续向上更新。

如果Parent的平衡因子为正负2，则Parent的平衡因子违反平衡树的性质，需要对其进行旋转处理。

下面来依次介绍各种旋转方式。

4.3选择旋转方式并更新平衡因子的值。

AVL树的旋转有4种方式：“左单旋”，“右单旋”，“左右双旋”，“右左双旋”。

4.3.1左单旋

在这里插入图片描述

圆圈为核心结点，正方形结点是辅助结点，可有可无。

左单旋的应用场景是：parent结点平衡因子是2，subR平衡因子是1。

当前结构中10代表的parent结点平衡因子是2，subR平衡因子是1，不满足AVL特性，进行如下反转：

先将subRL作为parent的右子树分支，再让parent作为subR的左子树分支。这就完成了左单旋。

旋转过后，我们发现，树的高度降下来了，又满足了AVL树的特性。

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

		if (subRL)
		{
			subRL->_parent = parent;
		}
		subR->_left = parent;
		parent->_parent = subR;

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


		subR->_bf = parent->_bf = 0;
	}
4.3.2右单旋

在这里插入图片描述

圆圈为核心结点，正方形结点是辅助结点，可有可无。

右单旋的应用场景为：parent的平衡因子是-2，subL的平衡影子是-1时。

当前parent结点的平衡因子是-2，subL的平衡因子是-1，不满足AVL特性，因此使用右单旋。

将subLR作为parent的左子树分支，再将parent作为subL的右子树分支。即完成右单旋。

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

		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		subL->_right = parent;
		parent->_parent = subL;


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

			subL->_parent = ppnode;

		}

		subL->_bf = parent->_bf = 0;
	}
4.3.3左右双旋

左右双旋的应用场景是：当新结点插入较高左子树的右侧。如下图

在这里插入图片描述
圆圈结点是核心结点，正方形结点是辅助结点，可有可无。

左右双旋的应用场景与左右双旋的稍有不同：插入的新结点在较高左子树的右侧

（也就是图1中subR中的位置）。他可以拆解为一次左单旋和右单旋。我们依次来看这个过程：

1.先左单旋（图1 -> 图2）：parent为红色结点，subR为黑色结点，以这两个结点为核心进行左单旋：

subRL作为parent的右子树，parent作为subR的左子树，同时subR代替parent成为蓝色结点的左子树。

2.再右单旋：parent为蓝色结点，subL为黑色结点，以这两个结点为核心进行右单旋：subLR作为

parent的左子树，parent作为subL的右子树，同时subL代替parent与其父亲结点相连（parent为根则设

置subL的父亲节点为空）

代码实现起来非常简单：

if ((parent->_bf == -2) && (cur->_bf == 1))//左右双旋
				{
					Node* subL = parent->_left;
					Node* subLR = subL->_right;
					int bf = subLR->_bf;

					_RotateL(parent->_left);
					_RotateR(parent);

					subLR->_bf = 0;
					if (bf == 1)
					{
						subL->_bf = -1;
						parent->_bf = 0;
					}
					else if (bf == -1)
					{
						parent->_bf = 1;
						subL->_bf = 0;
					}

				}

看到这里有人就会问了，左右双旋不就是一个左单旋加一个右单旋嘛，为什么代码多出来这么多？这

便是左右双旋和右左双旋的“坑”，下面我们来讲一讲这个坑是什么：

在这里插入图片描述

根据定义，左右双旋是要新结点在较高左子树的右边插入，但这里并没有更进一步的要求，所以由上

图我们可以分别在b/c底下插入新结点。在完成旋转后的图中，我们发现，60的左右子树分别被30和

90瓜分了，而60成为了30和90的父亲节点，平衡因子始终为0。而30，90则不同，根据插入位置的不

同，他们最终的平衡因子也是不同的。所以如果只是进行左右双旋而不对插入位置进行分类讨论，最

终你无法更新各个结点的平衡因子（因为你并不知道是在那个分支下插入）。

再来看一看我们之前的代码

if (parent->_bf == -2) && (cur->_bf == 1)//左右双旋
				{
					Node* subL = parent->_left;
					Node* subLR = subR->_right;
					int bf = subLR->_bf;

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

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

				}

subRL就是此处的60结点，在旋转前我们先保存60结点的平衡因子，旋转结束后，更新平衡因子前，

我们通过60号平衡因子的值来确定是在b处插入还是c出插入，再对应更新30（subL），90（parent）

的平衡因子。

4.3.4右左双旋

在这里插入图片描述

圆圈结点为核心结点，正方形结点是辅助结点，可有可无。

理解了左右双旋，右左双旋也是一个道理的。他适用于新结点插入位置在较高右子树的左边。

先进行右单旋：蓝色结点为parent，黑色结点为subL。让subLR作为parent的左子树，在让parent作为subL的右子树，subL代替parent与红色结点相连。

再进行右单旋：红色结点为parent，黑色结点为subR。让subRL作为parent的右子树，再让parent作为

subR的左子树，如果parent之前还有父亲结点，让subR成为其新的对应分支结点。

if ((parent->_bf == 2) && (cur->_bf == -1))//右左双旋
				{

					Node* subR = parent->_right;
					Node* subRL = subR->_left;
					int bf = subRL->_bf;

					_RotateR(parent->_right);
					_RotateL(parent);

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

到这里AVL树的插入就算完成了，以下是插入部分的完整代码

		void _RotateL(Node*& parent)
	{
		Node *ppnode = parent->_parent;
		Node *subR = parent->_right;
		Node *subRL = subL->_left;
		parent->_right = subRL;

		if (subRL != nullptr)
		{
			subRL->_parent = parent;
		}
		subR->_left = parent;

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

		subR->_bf = parent->_bf = 0;
	}
	void _RotateR(Node*& parent)
	{
		Node* ppnode = parent->_parent;
		Node* subL = parent->_left;
		Node* subLR = subR->_right;

		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		subL->_right = parent;
		

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

		parent->_parent = subL;
		subL->_bf = parent->_bf = 0;
	}
bool insert(const K& key)//插入
	{
		//1.判断空树
		if (_root == nullptr)
		{
			_root = new Node(key);

		}
		//2.查找位置
		Node* cur = _root;
		Node * parent = nullptr;

		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;//节点已经存在
			}
		}
		//3.插入数据
		cur = new Node(key);
		if (parent->_key > key)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		//4.验证平衡因子的值

		while (parent)
		{
			if (cur == parent->_left)
			{
				--(parent->_bf);
			}
			else
			{
				++(parent->_bf);
			}
			if (parent->_bf == 0)//说明之前的平衡因子值为-1或1，此时满足AVL树特性，调整结束
			{
				break;
			}
			else if (abs(parent->_bf) == 1)//说明之前的平衡因子值为0，需要向上调整。
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			else if (abs(parent->_bf) == 2)//说明已经不满足AVL树的特性，选择适当旋转方式
			{
				if ((parent->_bf == -2) && (cur->_bf == -1))//右单旋
				{
					_RotateR(parent);
				}
				if ((parent->_bf == 2) && (cur->_bf == 1))//左单旋
				{
					_RotateL(parent);
				}
				if (parent->_bf == -2) && (cur->_bf == 1)//左右双旋
				{
					Node* subL = parent->_left;
					Node* subLR = subR->_right;
					int bf = subLR->_bf;

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

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

				}
				if (parent->_bf == 2) && (cur->_bf == -1)//右左双旋
				{

					Node* subR = parent->_right;
					Node* subRL = subR->_left;
					int bf = subRL->_bf;

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

					subRL->_bf = 0;
					if (bf == 1)
					{
						subR->_bf = 0;
						parent->_bf = -1;
					}
					else if (bf == -1)
					{
						parent->_bf = 0;
						subR->_bf = 1;
					}
				}
				break;//调整之后一定符合AVL树特性，调整结束。
			}
			else//大于2的情况直接报错
			{
				assert(false);
			}
		}
		return true;
	}

5.AVL树的删除

尚未完成，后面再补充

6.AVL树的判定

	bool IsBlanceTree()
	{
		return _IsBlanceTree(_root);
	}
	bool _IsBlanceTree(Node *root)
	{
		if (root == nullptr)
		{
			return true;
		}


		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		int bf = rightHeight - leftHeight;
		if (bf != root->_bf)
		{
			std::cout << root->_key << "结点平衡因子异常";
		}

		return abs(rightHeight - leftHeight)< 2 && _IsBlanceTree(root->_left) && _IsBlanceTree(root->_right);
	}

7.AVL树的查找

和二叉搜索树一样

Node* find(const K& key)//查找
	{
		if (_root == nullptr)
			return nullptr;

		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else
				return cur;
		}
		return nullptr;
	}

8.AVL树的遍历

采用中序遍历的方式

void InOrder()
	{
		_InOrder(_root);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		std::cout << root->_key << " ";
		_InOrder(root->_right);
	}

最后来测试一下：

int a[ ] = { 2, 4, 3, 1, 0, 6, 5 };

依次向AVL树内插入数组内的数据，得到结果：
在这里插入图片描述

9.完整代码

#include<iostream>
#include<stdlib.h>
#include<assert.h>


template<class K>
struct AVLTreeNode
{
	K _key;//节点内的值

	AVLTreeNode<K>* _left;//左子树节点
	AVLTreeNode<K>* _right;//右子树节点
	AVLTreeNode<K>* _parent;//双亲节点

	int _bf;//平衡因子

	AVLTreeNode(const K& key)
		:_left(NULL)
		, _right(NULL)
		, _parent(NULL)
		, _key(key)
		, _bf(0)
	{}
};
template<class K>
class AVLTree
{
	typedef AVLTreeNode< K > Node;
public:
	size_t Height(Node* root)//计算树的高度
	{
		if (root == nullptr)
		{
			return 0;
		}

		size_t leftHeight = Height(root->_left);
		size_t rightHeight = Height(root->_right);

		return leftHeight > rightHeight ? (leftHeight + 1) : (rightHeight + 1);

	}
	void GetBf(Node *root)//计算平衡因子
	{
		if (root == nullptr)
		{
			return;
		}
		root->_bf = Height(root->_right) - Height(root->_left);
		if (abs(root->_bf) > 1)
		{
			std::cout << "节点" << root->_key << "的平衡因子有误！" << std::endl;
		}

		GetBf(root->_left);
		GetBf(root->_right);

	}
	bool insert(const K& key)
	{
		//1.判断空树
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;

		}
		//2.查找位置
		Node* cur = _root;
		Node * parent = nullptr;

		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;//节点已经存在
			}
		}
		//3.插入数据
		cur = new Node(key);
		if (parent->_key > key)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		//4.验证平衡因子的值

		while (parent)
		{
			if (cur == parent->_left)
			{
				--(parent->_bf);
			}
			else
			{
				++(parent->_bf);
			}
			if (parent->_bf == 0)//说明之前的平衡因子值为-1或1，此时满足AVL树特性，调整结束
			{
				break;
			}
			else if (abs(parent->_bf) == 1)//说明之前的平衡因子值为0，需要向上调整。
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			else if (abs(parent->_bf) == 2)//说明已经不满足AVL树的特性，选择适当旋转方式
			{
				if ((parent->_bf == -2) && (cur->_bf == -1))//右单旋
				{
					_RotateR(parent);
				}
				if ((parent->_bf == 2) && (cur->_bf == 1))//左单旋
				{
					_RotateL(parent);
				}
				if ((parent->_bf == -2) && (cur->_bf == 1))//左右双旋
				{
					Node* subL = parent->_left;
					Node* subLR = subL->_right;
					int bf = subLR->_bf;

					_RotateL(parent->_left);
					_RotateR(parent);

					subLR->_bf = 0;
					if (bf == 1)
					{
						subL->_bf = -1;
						parent->_bf = 0;
					}
					else if (bf == -1)
					{
						parent->_bf = 1;
						subL->_bf = 0;
					}
					

				}
				if ((parent->_bf == 2) && (cur->_bf == -1))//右左双旋
				{

					Node* subR = parent->_right;
					Node* subRL = subR->_left;
					int bf = subRL->_bf;

					_RotateR(parent->_right);
					_RotateL(parent);

					subRL->_bf = 0;
					if (bf == 1)
					{
						subR->_bf = 0;
						parent->_bf = -1;
					}
					else if (bf == -1)
					{
						parent->_bf = 0;
						subR->_bf = 1;
					}
				}
				break;//调整之后一定符合AVL树特性，调整结束。
			}
			else//大于2的情况直接报错
			{
				assert(false);
			}
		}
		return true;
	}

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

		if (subRL)
		{
			subRL->_parent = parent;
		}
		subR->_left = parent;
		parent->_parent = subR;

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


		subR->_bf = parent->_bf = 0;
	}
	void _RotateR(Node* parent)
	{
		Node* ppnode = parent->_parent;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		subL->_right = parent;
		parent->_parent = subL;


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

			subL->_parent = ppnode;

		}

		subL->_bf = parent->_bf = 0;
	}

	bool IsBlanceTree()
	{
		return _IsBlanceTree(_root);
	}
	
	bool _IsBlanceTree(Node *root)
	{
		if (root == nullptr)
		{
			return true;
		}


		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		int bf = rightHeight - leftHeight;
		if (bf != root->_bf)
		{
			std::cout << root->_key << "结点平衡因子异常";
		}

		return abs(rightHeight - leftHeight)< 2 && _IsBlanceTree(root->_left) && _IsBlanceTree(root->_right);
	}
	
	void InOrder()
	{
		_InOrder(_root);
	}
	
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		std::cout << root->_key << " ";
		_InOrder(root->_right);
	}
	
	Node* find(const K& key)
	{
		if (_root == nullptr)
			return nullptr;

		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else
				return cur;
		}
		return nullptr;
	}
private:
	Node* _root = nullptr;
};

测试代码

int main()
{
	AVLTree<int> t;


	int a[] = { 2, 4, 3, 1, 0, 6, 5 };


	for (auto e : a)
	{
		t.insert(e);
		std::cout << e << "->" << t.IsBlanceTree()<<std::endl;
	}

	t.InOrder();

	if (t.IsBlanceTree())
	{
		std::cout << "该树是AVL树" << std::endl;
	}
	else
	{
		std::cout << "该树不是AVL树" << std::endl;
	}
	system("pause");
}

猜你喜欢

转载自blog.csdn.net/Ferlan/article/details/86183797
今日推荐
周排行
Leetcode简单题61~80
解决zookeeper磁盘IO高的问题
多线程相关方法详解
Maven-setting.xml文件详解
Maven 项目的 classpath 理解
渊亭科技大数据笔试题
配置JVM内存分配
计算机网络个人学习笔记 （三）网络层 ：第三部分 连载
js中两个等号(==)和三个等号(===)的区别
用C程序自动打开电脑上的程序
每日归档
更多
2024-09-18(0)
2024-09-17(0)
2024-09-16(0)
2024-09-15(0)
2024-09-14(0)
2024-09-13(0)
2024-09-12(0)
2024-09-11(0)
2024-09-10(0)
2024-09-09(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022