AVL树实现(含删除)

上网借鉴人家的,并没有进行测试。

#ifndef AVLTree_H

#define AVLTree_H



template<typename T>

class AVLTree

{

	AVLTree();

	AVLTree(const AVLTree & rhs);

	~AVLTree();



	const T & findMin() const;

	const T & findMax() const;

	bool contains(const T & x) const;

	bool isEmpty() const;

	void printTree() const;



	void makeEmpty();

	void insert(const T & x);

	void remove(const T & x);



	const AVLTree & operator=(const AVLTree & rhs);



private:

	struct AVLNode

	{

		T element;

		int height;

		AVLNode * left;

		AVLNode * right;

		AVLNode(const T & theElement,AVLNode *lt = NULL,AVLNode *rt = NULL,int h = 0):element(theElement),left(lt),right(rt),height(h) {}

	};



	AVLTree * root;

	int max(int a,int b)

	{

		return a > b ? a:b;

	}



	void insert(const T & x,AVLTree * &t) const

	{

		if(t == NULL)

			t = new AVLNode(x);

		else if(x < t->element)

		{

			insert(x,t->left);

			if(height(t->left) - height(t->right) == 2)

			{	

				if(x < t->element->left)

			    {

					rotateWithLeftChild(t);

				}

				else

				{

					doubleWithLefrChild(t);

				}

			}

		}

		else if(x > t->element)

		{

			insert(x,t->right);

			if(height(t->right) - height(t->left) == 2)

			{

				if(x > t->right->element)

					rotateWithRightChild(t);

				else

					doubleWithRightChild(t);

			}

		}

		else

			t -> height = max(height(t->left),height(t->right) ) +1;

	}



	void remove(const T & x,AVLNode * &t) const

	{

		if(t == NULL)

			return ;

		if(x == t->element)

		{

			if(t->right == NULL)    //如果t的右儿子为空则直接删除

			{

				AVLNode* temp = t;

				t = t->left;

				delete temp;

			}

			else    //否则,找t->right的最左儿子来替代(即t的直接后继)

			{

				AVLNode* temp = t->right;

				t->element = findMin(temp)->element;

				t->right = remove(t->element,t->right);

				t->height = max(height(t->left),height(t->right)) + 1;

			}

			return t;

		}

		else if(x < t->element)

			t->left = remove(x,t->left);

		else

			t->right = remove(x,t->right);

		t->height = max(height(t->left),height(t->right)) + 1;

		if(t->left != NULL)

			t->left = rotate(t->left);

		if(t->right != NULL)

			t->right = rotate(t->right);

		t = rotate(t);

		return t;

	}

			

	AVLNode * findMin(AVLNode * t) const

	{

		if(t == NULL)

			return NULL;

		else

		{

			while(t->left != NULL)

				t = t->left;

			return t;

		}

	}

	AVLNode * findMax(AVLNode * t) const

	{

		if(t == NULL)

			return NULL;

		else

		{

			while(t->right != NULL)

				t = t->right;

			return t;

		}

	}

	bool contains(const T & x,AVLNode *t) const

	{

		if(t == NULL)

			return false;

		else if(x < t->element)

			return contains(x,t->left);

		else if(c > t->element)

			return contains(x,t->right);

		else

			return true;

	}

	void makeEmpty(AVLNode *t) const

	{

		if(t == NULL)

			;

		else

		{

			makeEmpty(t->left);

			makeEmpty(t->right);

			delete t;

		    t = NULL;

		}

	}

	AVLNode * clone(AVLNode * t) const

	{

		if(t == NULL)

			return NULL;

		else

			return new AVLNode(t->element,clone(t->left),clone(t->right));

	}

	void printTree(AVLNode * &t) const

	{//这里采用中缀遍历

		cout << t->element << endl;

		printTree(t->left);

		printTree(t->right);

	}

	int height(AVLNode * t) const

	{

		return t == NULL ? -1 : t->height;

	}

	AVLNode* rotateWithLeftChild(AVLNode * & k2)

	{

		AVLNode * k1 = k2->left;

		k2->left = k1->right;

		k1->right = k2;

		k2->height = max(height(k2->left),height(k2->right)) +1;

		k1->height = max(height(k2->left),height(k2->right)) +1;

		k2 = k1;

		return k1;

	}

	AVLNode* doubleWithLeftChild(AVLNode * & k3)

	{

		rotateWithLeftChild(k3->left);

		return rotateWithLeftChild(k3);

	}

	AVLNode* rotateWithRightChild(AVLNode * & k2)

	{

		AVLNode * k1 = k2->right;

		k2->right = k1->left;

		k1->left = k2;

		k2->height = max(height(k2->right),height(k2->left)) +1;

		k1->height = max(height(k2->right),height(k2->left)) +1;

		k2 = k1;

		return k1;

	}

	AVLNode* doubleWithRightChild(AVLNode * & k3)

	{

		rotateWithRightChild(k3->right);

		return rotateWithRightChild(k3);

	}



	//对单个结点进行AVL调整

	AVLNode* rotate(AVLNode * t)

	{

		if(height(t->left) - height(t->right) == 2)

		{

			if(height(t->left->left) >= height(t->left->right))

				t = rotateWithLeftChild(t);

			else

				t = doubleWithLeftChild(t);

		}

		else if(height(t->right) - height(t->left) == 2)

		{

			if(height(t->right->right) >= height(t->right->left))

				t = rotateWithRightChild(t);

			else

				t = doubleWithRightChild(t);

		}

		return t;

	}

};



#endif

 

#include "AVLTree.h"

#include <iostream>

using namespace std;



template<typename T>

AVLTree<T>::AVLTree()

{

	root = NULL;

}



template<typename T>

AVLTree<T>::AVLTree(const AVLTree & rhs)

{

	root = NULL;

	*this = rhs;

}



template<typename T>

AVLTree<T>::~AVLTree()

{

	makeEmpty();

}



template<typename T>

const T & AVLTree<T>::findMin() const

{

	if(!isEmpty())

		return findMin(root)->element;

}



template<typename T>

const T & AVLTree<T>::findMax() const

{

	if(!isEmpty())

		return findMax(root)->element;

}



template<typename T>

bool AVLTree<T>::contains(const T & x) const

{

	return contains(x,root);

}



template<typename T>

bool AVLTree<T>::isEmpty() const

{

	return root == NULL;

}



template<typename T>

void AVLTree<T>::printTree() const

{

	if(isEmpty())

		cout << "Empty tree." << endl;

	else

		printTree(root);

}



template<typename T>

void AVLTree<T>::makeEmpty()

{

	makeEmpty(root);

}



template<typename T>

void AVLTree<T>::insert(const T & x)

{

	insert(x,root);

}



template<typename T>

void AVLTree<T>::remove(const T & x)

{

	remove(x,root);

}





/* Deep Copy*/



template<typename T>

const AVLTree<T> &AVLTree<T>::operator=(const AVLTree<T> & rhs)

{

	if( this != &rhs )

	{

		makeEmpty();

		root = clone(rhs.root);

	}

	return *this;

}