cpp笔记AVLTree

搜索二叉树以速率为O（lngN）也就是和二分查找相同的速率，实际原理也是相同。

先看代码：

#pragma once
#include<iostream>
#include<set>
#include<map>
using namespace std;


//AVLTree
template<class K,class V>
struct AVTreeNode
{
	AVTreeNode<K, V>* _left;
	AVTreeNode<K, V>* _right;
	AVTreeNode<K, V>* _parent;

	int _bf;//balance factor平衡因子

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

template<class K,class V>
class AVLTree
{
	typedef AVTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		//1、先按搜索树的规则进行插入
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			parent = cur;
			if (cur->_kv.first > kv.first)
			{
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)
			{
				cur=cur->_right;
			}
			esle
			{
				return false;
			}

			cur = new Node(kv);
			if (parent->_kv.first < kv->first)
			{
				parent->_right = cur;
				cur->_parent = parent;
			}
			else
			{
				parent->_left = cur;
				cur->_parent = parent;
			}

			//2、跟新平衡因子
			while (parent)//一直跟新到parent为nullptr为止 
			{
				if (cur == parent->_right)//新增节点在右，平衡因子++
				{
					++parent->_bf;
				}
				else//新增节点在左，平衡因子--
				{
					--parent->_bf;
				}
				if (parent->_bf == 0)//这里表示新增节点让二叉树平衡了
				{
					break;
				}
				else if (parent->_bf == 1 || parent->_bf == -1)
				{
					cur = parent;
					parent = parent->_parent;//向上迭代（向parent迭代）
				}
				else if (parent->_bf == 2 || parent->_bf == -2)//出现了不平衡，需要旋转修改不平衡
				{
					//parent所在的子树出现不平衡了，需要旋转处理一下
					if (parent->_bf == 2)//右子树过长
					{
						if (cur->_bf == 1)//新增节点在右，也就是右斜线路径只需要左单旋
							RotateL(parent);
						else if (cur->_bf == -1)//新增节点在左，形成了折线路径，需要右单旋加上左单旋（右左旋）
						{
							RotateRL(parent);
						}
					}
					else if (parent->_bf == -2)//左子树过长
					{
						if (cur->_bf == -1)//左斜线
							RotateR(parent);//右单旋
						else if (cur->_bf == 1)
						{
							RotateLR(parent);//左右旋
						}
					}
				}
			 }
			return true;
		}
	}
	//单左
	void RotateL(Node* parent)//单左旋，也就是右斜线需要的（形状为\）
	{
		Node* subR = parent->_right;//右斜线，直接取parent->_right即可
		Node* subRL = subR->_left;//parent会接收subRL，然后用parent来接替subRL，而subR会成为新的parent

		parent->_right = subRL;//subR大于parent，因此subRL依然大于parent；
		if (subRL)//判断是否为nullptr
		{
			subRL->_parent = parent;
		}

		subR->_left = parent;//subR的左指针指向parent
		Node* ppNode = parent->_parent;//记录parent->_parent，用于旋转后给subR继承parent->_parent
		parent->_parent = subR;//改变parent后，也需要改变_parent

		//1、原来parent是这棵树的根，现在subR是根
		//2、parent为根的树只是整棵树中的子树，改变了链接关系，那么subR就替换了位置
		if (_root == parent)//当parent为根时，根时没有_parent，也就设立为nullptr
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else//parent!=_root
		{
			if (ppNode->_left == parent)//判断parent是在parent->_parent->_left or parent->_parent->_right
				ppNode->_left = subR;
			else
				ppNode->_right = subR;

			subR->_parent = ppNode;
		}
		parent->_bf = subR->_bf = 0;//旋转后，该子树已经平衡
	}
	//单右
	void RotateR(Node* parent)//左斜线(形状为/)
	{
		Node* subL = parent->_left;//该节点旋转后会成为parent
		Node* subLR = subL->_right;//parent需要链接在左指针的节点

		parent->_left = subLR;//subL小于parent，因此subLR依然小于parent
		if (subLR)//判断subLR是否为nullptr
			subLR->_parent = parent;

		subL->_right = parent;//旋转，让parent链接到subL->_right
		Node* ppNode = parent->__parent;//记录parent->_parent，方便后期subL的改变
		parent->_parent = subL;

		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else//parent不为根
		{
			if (ppNode->_left == parent)//判断parent在parent->_parent的左还是右
				ppNode->_left = subL;//链接改变后的subL（新parent）
			else
				ppNode->_right = subL;
		}
		parent->_bf = subL->_bf = 0;//平衡后改变平衡因子
	}
	void RotateRL(Node* parent)//右左旋转（形状为>）
	{
		Node* subR = parent->_right;//看形状知道中间节点为parent->right
		Node* subRL = subR->_left;//双旋转后subRL会被更改为新的parent
		int bf = subRL->_bf;//记录增加节点在subRL的左还是右

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

		if (bf == -1)//增加的节点在左
		{
			parent->_bf = 0;//旋转后，新增节点会出现在parent->_right,让parent左右子树平衡
			subR->_bf = 1;//旋转后subR接收了subRL->_right==h-1和本身的subR->_right==h，导致了右节点高
			subRL->_bf = 0;//subRL已经成为新的parent，旋转后subRL一定为0（一定平衡）
		}
		else if (bf == 1)//增加的节点在右
		{
			subRL->_bf = 0;//新parent
			subR->_bf = 0;//subR->_left==增加的节点（h-1）+1，subR->_right大小为h
			parent->_bf = -1;//parent->_left大小为h，parent->_right大小为h-1
		}
		else//只有三个节点，且叶子节点都为nullptr
		{
			subR->_bf = subRL->_bf = parent->_bf = 0;
		}
	}
	void RotateLR(Node* parent)//左右旋（形状很像<）
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

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

		if (bf == -1)
		{
			parent->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			parent->_bf = subLR->_bf = 0;
		}
		else
		{
			subL->_bf = subLR->_bf = parent->_bf = 0;
		}
	}
	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 IsBalance(Node* root)
	{
		if (root == nullptr)
			return true;

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

		return abs(leftHeight - rightHeight < 2) && IsBalance(root->_left)&&IsBalance(root->_right);
	}
private:
	Node* _root = nullptr;
};

 右单旋

左单旋 

 

左右旋

 

 右左旋