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;
}