#include <iostream>
using namespace std;
template<class Comparable>
class AvlTree
{
public:
AvlTree();
AvlTree(const AvlTree& rhs);
~AvlTree();
public:
const Comparable& findMin() const; //find the minimum value
const Comparable& findMax() const; //find the maximum value
bool contains(const Comparable& x) const; //Determine whether the tree contains x
bool isEmpty() const; //Determine whether the tree is empty
void printTree() const; //print the binary Tree
int size() const; //return the tree's size
void makeEmpty(); //make Avl tree empty
void insert(const Comparable& x); //insert a value into Avl tree
void remove(const Comparable& x); //remove a value from Avl tree
const AvlTree& operator= (const AvlTree& rhs); //overload operator =
private:
struct AvlNode
{
Comparable element;
AvlNode* left;
AvlNode* right;
AvlNode* parent;
AvlNode() {}
AvlNode(const Comparable& theElem, AvlNode* lt, AvlNode* rt, AvlNode* pt, int ht = 0) : element(theElem), left(lt),
right(rt), parent(pt), height(ht){}
int height;
};
AvlNode* root; //define the root node
void insert(const Comparable& x, AvlNode *&t, AvlNode *parent = NULL) const;
void remove(const Comparable& x, AvlNode *&t);
AvlNode* findMin(AvlNode* t) const;
AvlNode* findMax(AvlNode* t) const;
bool contains(const Comparable& x, AvlNode* t) const;
void printTree(AvlNode* t) const;
void makeEmpty(AvlNode *&t) const;
AvlNode* clone(AvlNode *t) const;
int height(AvlNode *t) const;
void rotateWithLeftChild(AvlNode *&k2); //LL单旋转
void doubleWithLeftChild(AvlNode *&k3); //LR双旋转
void rotateWithRightChild(AvlNode *&k2); //RR单旋转
void doubleWithRightChild(AvlNode *&k3); //RL单旋转
int length;
};
template<class Comparable>
AvlTree<Comparable>::AvlTree() : length(0)
{
root = new AvlNode(); //constructor construct a tree without subtree
root = NULL;
}
template<class Comparable>
AvlTree<Comparable>::AvlTree(const AvlTree& rhs)
{
root = new AvlNode();
root = NULL;
makeEmpty();
root = clone(rhs.root);
length = rhs.length;
}
template<class Comparable>
AvlTree<Comparable>::~AvlTree()
{
makeEmpty();
}
template<class Comparable>
const Comparable& AvlTree<Comparable>::findMin() const
{
return findMin(root)->element;
}
template<class Comparable>
const Comparable& AvlTree<Comparable>::findMax() const
{
return findMax(root)->element;
}
template<class Comparable>
int AvlTree<Comparable>::size() const
{
return length;
}
template<class Comparable>
bool AvlTree<Comparable>::contains(const Comparable& x) const
{
return contains(x, root);
}
template<class Comparable>
bool AvlTree<Comparable>::isEmpty() const
{
return root == NULL;
}
template<class Comparable>
void AvlTree<Comparable>::printTree() const
{
printTree(root);
}
template<class Comparable>
void AvlTree<Comparable>::makeEmpty()
{
makeEmpty(root);
length = 0;
}
template<class Comparable>
void AvlTree<Comparable>::insert(const Comparable& x)
{
insert(x, root);
++length;
}
template<class Comparable>
void AvlTree<Comparable>::remove(const Comparable& x)
{
remove(x, root);
--length;
}
template<class Comparable>
const AvlTree<Comparable>& AvlTree<Comparable>::operator= (const AvlTree& rhs)
{
if(this != &rhs)
{
makeEmpty();
root = clone(rhs.root);
length = rhs.length;
}
return *this;
}
template<class Comparable>
void AvlTree<Comparable>::insert(const Comparable& x, AvlNode *&t, AvlNode *parent = NULL) const
{
if(t == NULL)
t = new AvlNode(x, NULL, NULL, parent);
else if(x < t -> element)
{
insert(x, t -> left, t);
if(height(t -> left) - height(t -> right) == 2)
{
if(x < t -> left -> element)
rotateWithLeftChild(t);
else
doubleWithLeftChild(t);
}
}
else if(t -> element < x)
{
insert(x, t -> right, t);
if(height(t -> right) - height(t -> left) == 2)
{
if(x < t -> right -> element)
doubleWithRightChild(t);
else
rotateWithRightChild(t);
}
}
else
; //do nothing
t -> height = max(height(t -> left), height(t -> right)) + 1;
}
template<class Comparable>
void AvlTree<Comparable>::remove(const Comparable& x, AvlNode *&t)
{
if (t == NULL)
return;
if(x < t -> element)
{
remove(x, t -> left);
if(t != NULL)
t -> height = max(height(t -> left), height(t -> right)) + 1;
if(height(t -> right) - height(t -> left) == 2)
{
if(t -> right -> right -> height > t -> right -> left -> height)
{
rotateWithRightChild(t);
}
else
{
doubleWithRightChild(t);
}
}
}
else if(t -> element < x)
{
remove(x, t -> right);
if(t != NULL)
t -> height = max(height(t -> right), height(t -> left)) + 1;
if(height(t -> left) - height(t -> right) == 2)
{
if(t -> left -> left -> height > t -> left -> right -> height)
{
rotateWithLeftChild(t);
}
else
{
doubleWithLeftChild(t);
}
}
}
else if(t -> left != NULL && t -> right != NULL)
{
t -> element = findMin(t -> right) -> element;
remove(t->element, t->right);
}
else
{
AvlNode *oldNode = t;
AvlNode *oldParent = t -> parent;
t = (t -> left != NULL) ? t -> left : t -> right;
if(t != NULL)
t -> parent = oldParent;
delete oldNode;
}
}
template<class Comparable>
typename AvlTree<Comparable>::AvlNode* AvlTree<Comparable>::findMin(AvlNode *t) const
{
if(t == NULL)
return NULL;
if(t -> left == NULL)
return t;
return findMin(t -> left);
}
template<class Comparable>
typename AvlTree<Comparable>::AvlNode* AvlTree<Comparable>::findMax(AvlNode *t) const
{
if(t == NULL)
return NULL;
if(t -> right == NULL)
return t;
return findMax(t -> right);
}
template<class Comparable>
bool AvlTree<Comparable>::contains(const Comparable& x, AvlNode* t) const
{
if(t == NULL)
return false;
else if(x < t -> element)
return contains(x, t -> left);
else if(t -> element < x)
return contains(x, t -> right);
else
return true;
}
template<class Comparable>
void AvlTree<Comparable>::makeEmpty(AvlNode*& t) const
{
if(t != NULL)
{
makeEmpty(t -> left);
makeEmpty(t -> right);
delete t;
}
t = NULL;
}
template<class Comparable>
void AvlTree<Comparable>::printTree(AvlNode* t) const
{
if(t != NULL)
{
cout << t ->element << "\t";
printTree(t -> left);
cout << endl;
printTree(t -> right);
}
}
template<class Comparable>
typename AvlTree<Comparable>::AvlNode* AvlTree<Comparable>::clone(AvlNode *t) const
{
if(t == NULL)
return NULL;
return new AvlNode(t -> element, clone(t -> left), clone(t -> right), t -> parent);
}
template<class Comparable>
int AvlTree<Comparable>::height(AvlNode* t) const
{
return (t == NULL) ? -1 : t -> height;
}
template<class Comparable>
void AvlTree<Comparable>::rotateWithLeftChild(AvlNode *&k2)
{
AvlNode* k1 = k2 -> left;
k2 -> left = k1 -> right;
k1 -> right = k2;
k1 -> parent = k2 -> parent;
k2 -> parent = k1;
k2 -> height = max(height(k2 -> left), height(k2 -> right)) + 1;
k1 -> height = max(height(k1 -> left), k2 -> height) + 1;
k2 = k1;
}
template<class Comparable>
void AvlTree<Comparable>::doubleWithLeftChild(AvlNode *&k3)
{
rotateWithRightChild(k3 -> left);
rotateWithLeftChild(k3);
}
template<class Comparable>
void AvlTree<Comparable>::rotateWithRightChild(AvlNode *&k2)
{
AvlNode* k1 = k2 -> right;
k2 -> right = k1 -> left;
k1 -> left = k2;
k1 -> parent = k2 -> parent;
k2 -> parent = k1;
k2 -> height = max(height(k2 -> left), height(k2 -> right)) + 1;
k1 -> height = max(height(k1 -> right), k2 -> height) + 1;
k2 = k1;
}
template<class Comparable>
void AvlTree<Comparable>::doubleWithRightChild(AvlNode *&k3)
{
rotateWithLeftChild(k3 -> right);
rotateWithRightChild(k3);
}
int main()
{
return 0;
}
数据结构avlTree C++实现
最新推荐文章于 2022-11-08 14:59:13 发布