AVL树的实现

//avl_tree.h
#include <stack>
using std::stack;

template <typename T>
class AVL_TREE
{
public:
AVL_TREE(){
nil = new AVL_NODE(0, -1, NULL, NULL);
tree_root = nil;
}
bool find(const T &val) const;
void insert(const T &val);
void del(const T &val);//惰性删除

typedef struct tagAVL_NODE
{
bool exist;
T data;
int height;
struct tagAVL_NODE *left, *right;
tagAVL_NODE(const T &val, int wg, tagAVL_NODE *cl, tagAVL_NODE *cr){
data = val;
height = wg;
left = cl;
right = cr;
exist = 1;
}
}AVL_NODE;

private:
AVL_NODE* tree_root, * nil;
AVL_NODE* own_insert(AVL_NODE* tree, const T &val);
AVL_NODE* rolatewithleft(AVL_NODE *p);
AVL_NODE* rolatewithright(AVL_NODE *p);
};
template <typename T> bool AVL_TREE<T>::find(const T &val) const
{
AVL_NODE *p = tree_root;
while (p != nil && p->data != val)
{
if (p->data < val)
p = p->right;
else if (p->data > val)
p = p->left;
}
return p != nil && p->data == val && p->exist;
}
template <typename T> typename AVL_TREE<T>::AVL_NODE* AVL_TREE<T>::rolatewithleft(AVL_NODE *p)
{
AVL_NODE *h = p->left;
p->left = h->right;
h->right = p;
p->height = p->left->height > p->right->height ? p->left->height + 1 : p->right->height + 1;
h->height = h->left->height > h->right->height ? h->left->height + 1 : h->right->height + 1;
return h;
}
template <typename T> typename AVL_TREE<T>::AVL_NODE* AVL_TREE<T>::rolatewithright(AVL_NODE *p)
{
AVL_NODE *h = p->right;
p->right = h->left;
h->left = p;
p->height = p->left->height > p->right->height ? p->left->height + 1 : p->right->height + 1;
h->height = h->left->height > h->right->height ? h->left->height + 1 : h->right->height + 1;
return h;
}

template <typename T> void AVL_TREE<T>::insert(const T &val)
{
AVL_NODE *p = own_insert(tree_root, val);
if (tree_root == nil)
{
tree_root = p;
}
else if (p->left == tree_root || p->right == tree_root)
tree_root = p;
}
template <typename T> typename AVL_TREE<T>::AVL_NODE* AVL_TREE<T>::own_insert(AVL_NODE* tree, const T &val)
{
if (nil == tree)
tree = new AVL_NODE(val, 0, nil, nil);
else if (val > tree->data)
{
tree->right = own_insert(tree->right, val);
if (2 == tree->right->height - tree->left->height)
{
if (val > tree->right->data)
tree = rolatewithright(tree);
else
{
tree->right = rolatewithleft(tree->right);
tree = rolatewithright(tree);
}
}
}
else if (val < tree->data)
{
tree->left = own_insert(tree->left, val);
if (2 == tree->left->height - tree->right->height)
{
if (val < tree->right->data)
tree = rolatewithleft(tree);
else
{
tree->left = rolatewithright(tree->left);
tree = rolatewithleft(tree);
}
}
}
else //val == tree->data
{
tree->exist = 1;
}
if (tree != nil) tree->height = (tree->right->height > tree->left->height ? tree->right->height : tree->left->height) + 1;
return tree;
}
template <typename T> void AVL_TREE<T>::del(const T &val)
{
AVL_NODE *p = tree_root;
while (p != nil && p->data != val)
{
if (p->data < val)
p = p->right;
else if (p->data > val)
p = p->left;
}
if (p != nil && p->data == val)
p->exist = 0;
}