c++实现AVLTree--非递归插入

#include <queue>
#include <stack>
#include <iostream>
namespace _AVL_TREE
{
	
	template <typename T>
	class AVT;
	template <typename T>
	class AVTNode
	{
		friend class AVT<T>;
	public:
		AVTNode(){}
		AVTNode(const T &v, AVTNode<T> *l = 0, AVTNode<T> *r = 0,AVTNode<T> *p=0) 
			:val(v), left(l), right(r),parent(p)
		{
			avl = 0;
			hight = 0;
		}
	private:
		T val;
		AVTNode<T> *left, *right;
		AVTNode<T> *parent;
		int avl, hight;
	};
	template <typename T>
	class AVT
	{
	private:
		AVTNode<T> *root;
		void clear();
		static void visit(AVTNode<T> *);
		static void del(AVTNode<T> *);
		AVTNode<T> *LLRotation(AVTNode<T> *);
		AVTNode<T> *RRRotation(AVTNode<T> *);
		AVTNode<T> *LRRotation(AVTNode<T> *);
		AVTNode<T> *RLRotation(AVTNode<T> *);
		int max(int x, int y)
		{
			return x > y ? x : y;
		}
		void modavl(AVTNode<T> *);
		//void modNode(AVTNode<T> *node);
		//void height(AVTNode<T> *node);
	public:
		AVT()
		{
			root = 0;
		}
		~AVT()
		{
			clear();
		}
		void insert(const T &);
		void breadthFirst(void(*func)(AVTNode<T> *) = &AVT<T>::vist);
		AVTNode<T> * search(const T &e) const;
		//void deletenode(const T &);
	};
	template <typename T>
	AVTNode<T> * AVT<T>::LLRotation(AVTNode<T> *root)
	{
		//旋转
		AVTNode<T> *leftc = root->left;
		root->left = leftc->right;
		//更新父指针的值	
		if (leftc->right)
			leftc->right->parent = root;
		leftc->right = root;
		leftc->parent = root->parent;
		root->parent = leftc;
		//更新avl值
		//modNode(root);
		//modNode(leftc);
		return leftc;
	}
	template <typename T>
	AVTNode<T> *AVT<T>::RRRotation(AVTNode<T> *root)
	{
		AVTNode<T> *rightc = root->right;
		root->right = rightc->left;
		if (rightc->left)
			rightc->left->parent = root;
		rightc->left = root;
		rightc->parent = root->parent;
		root->parent = rightc;
		//modeNode(root);
		//modeNode(rightc);
		return rightc;
	}
	
	template <typename T>
	AVTNode<T> *AVT<T>::LRRotation(AVTNode<T> *root)
	{
		root->left = RRRotation(root->left);
		return LLRotation(root);
	}
	template <typename T>
	AVTNode<T> *AVT<T>::RLRotation(AVTNode<T> *root)
	{
		root->right = LLRotation(root->right);
		return RRRotation(root);
	}
	template <typename T>
	void AVT<T>::modavl(AVTNode<T> *p)
	{
		AVTNode<T> *c;
		if (p->avl == 2)
		{
			c = p->right;
			if (c->avl == 1)
			{
				//更新avl值 +2 +1->0 0
				c->avl = 0;
				p->avl = 0;
				//RR型
				if (p == root)
				{
					root = RRRotation(p);
					return;
				}
				c = p;
				p = p->parent;
				if (c == p->right)
					p->right = RRRotation(c);
				else
					p->left = RRRotation(c);
			}
			else if (c->avl == -1)
			{
				//更新avl值：
				//+2 -1 +1 -> -1 0 0
				if (c->left->avl == 1)
				{
					c->left->avl = 0;
					c->avl = 0;
					p->avl = -1;
				}
				//+2 -1 -1 -> 0 1 0
				else if (c->left->avl == -1)
				{
					c->left->avl = 0;
					c->avl = 1;
					p->avl = 0;
				}
				else
				{
					c->left->avl = 0;
					c->avl = 0;
					p->avl = 0;
				}
				//RL型
				if (p == root)
				{
					root = RLRotation(p);
					return;
				}
				c = p;
				p = p->parent;
				if (c == p->right)
					p->right = RLRotation(c);
				else
					p->left = RLRotation(c);
			}
		}
		else if (p->avl == -2)
		{
			c = p->left;
			if (c->avl == -1)
			{
				//更新avl
				//-2 -1 -> 0 0
				c->avl = 0;
				p->avl = 0;
				//LL型
				if (p == root)
				{
					root = LLRotation(p);
					return;
				}
				c = p;
				p = p->parent;
				if (c == p->right)
					p->right = LLRotation(c);
				else
					p->left = LLRotation(c);
			}
			else if (c->avl == 1)
			{
				//更新avl
				//-2 +1 +1 -> 0 -1 0
				if (c->right->avl == 1)
				{
					c->right->avl = 0;
					c->avl = -1;
					p->avl = 0;
				}
				//-2 +1 -1 ->-1 0 0
				else if (c->right->avl == -1)
				{
					c->right->avl = 0;
					c->avl = 0;
					p->avl = -1;
				}
				else
				{
					c->right->avl = 0;
					c->avl = 0;
					p->avl = 0;
				}
				//LR型
				if (p == root)
				{
					root = LRRotation(p);
					return;
				}
				c = p;
				p = p->parent;
				if (c == p->right)
					p->right = LRRotation(c);
				else
					p->left = LRRotation(c);
			}
		}
	}
	template <typename T>
	void AVT<T>::insert(const T &v)
	{
		if (root == 0)
		{
			root = new AVTNode<T>(v);
			return;
		}
		AVTNode<T> *p = root, *c = root;
		while (c)
		{
			if (v == c->val)
				return;
			else if (v < c->val)
			{
				p = c;
				c = c->left;
			}
			else
			{
				p = c;
				c = c->right;
			}
		}
		if (v>p->val)
		{
			p->right = new AVTNode<T>(v);
			p->right->parent = p;
			p->avl++;
		}
		else
		{
			p->left = new AVTNode<T>(v);
			p->left->parent = p;
			p->avl--;
		}
		while (p != root&&p->avl != 2 && p->avl != -2)
		{
			c = p;
			if (c->avl == 0)
				return;
			p = p->parent;
			if (c == p->left)
				--p->avl;
			else
				++p->avl;
		}
		modavl(p);
	}
	template <typename T>
	inline void AVT<T>::visit(AVTNode<T> *node)
	{
		std::cout << node->val << ' ';
		return;
	}
	template <typename T>
	inline void AVT<T>::del(AVTNode<T> *node)
	{
		delete node;
	}
	template <typename T>
	inline void AVT<T>::clear()
	{
		breadthFirst(del);
		root = 0;
	}
	template <typename T>
	void AVT<T>::breadthFirst(void(*func)(AVTNode<T> *) = &AVT<T>::visit)
	{
		std::queue<AVTNode<T> *> que;
		AVTNode<T> *p = root;
		if (p == 0)
			return;
		que.push(p);
		while (!que.empty())
		{
			p = que.front();
			que.pop();
			if (p->left)
				que.push(p->left);
			if (p->right)
				que.push(p->right);
			func(p);
		}
	}

	template <typename T>
	AVTNode<T> * AVT<T>::search(const T&v)
	{
		AVTNode<T> *p = root;
		while (p)
		{
			if (p->val == v)
			{
				return p;
			}
			if (p->val > v)
			{
				p = p->left;
			}
			else
				p = p->right;
		}
		return p;
	}
}