二叉查找树实现-双向链表

////二叉查找树，为了实现方便，给每个节点添加了一个指向父节点的指针
#include<iostream>
#include<vector>
#include<ctime>
#include<cstdlib>

using namespace std;

template<class T>
class BinarySearchTree
{
private:
struct Node
{
T data;
int deep;
Node *left;
Node *right;
Node *prev;
Node(T val,int deep)
{
data = val;
deep = 0;
left = NULL;
right = NULL;
prev = NULL;
}

private:
Node()
{
}
};
Node *root;
int size;

public:
BinarySearchTree()
{
root = NULL;
size = 0;
}
~BinarySearchTree()
{
clear(root);
root = NULL;
size = 0;
}
T min(Node *node) const
{
if(node->left == NULL)
return node->data;
else
return min(node->left);
}
T max(Node *node) const
{
if(node->right == NULL)
return node->data;
else
return max(node->right);
}

Node *insert(Node *& node,T val)
{
if(size == 0 && node == NULL)
{
root = new Node(val,0);
root->prev = NULL;
size++;
return root;
}
if(size != 0 && node == NULL)
{
cout<<"ERROR\n";
return NULL;
}
if(val > node->data)
{
if(node->right != NULL)
return insert(node->right,val);
else
{
Node *tmp = new Node(val,node->deep+1);
tmp->prev = node;
node->right = tmp;
size++;
return tmp;
}
}
else if(val < node->data)
{
if(node->left != NULL)
return insert(node->left,val);
else
{
Node *tmp = new Node(val,node->deep+1);
tmp->prev = node;
node->left = tmp;
size ++;
return tmp;
}
}
else if(val == node->data)
{
}
}

bool contain(Node *node,T val) const
{
if(node == NULL)
return false;

if(val > node->data)
return contain(node->right,val);
else if(val < node->data)
return contain(node->left,val);
else
return true;
}
void removeNode(Node *node)
{
if(node->left == NULL && node->right == NULL)
{
if(node->prev->left == node)
node->prev->left = NULL;
else
node->prev->right = NULL;

delete node;
size--;
}
else if(node->left == NULL)
{
node->right->prev = node->prev;
if(node->prev->left == node)
node->prev->left = node->right;
else
node->prev->right = node->right;

decDeep(node->right);
delete node;
size--;
}
else if(node->right == NULL)
{
node->left->prev = node->prev;
if(node->prev->left == node)
node->prev->left = node->left;
else
node->prev->right = node->left;

decDeep(node->left);
delete node;
size--;
}
else
{
Node *p = node->right;
while(p->left != NULL)
{
p=p->left;
}
node->data = p->data;
if(p->right != NULL)
{
p->prev->left = p->right;
p->right->prev = p->prev;
decDeep(p->right);
delete p;
size--;
}
else
{
p->prev->left = NULL;
delete p;
size--;
}
}
}
void decDeep(Node *node)
{
node->deep--;
if(node->left != NULL)
decDeep(node->left);
if(node->right != NULL)
decDeep(node->right);
}
void remove(T val)
{
Node * p=root;
while(1)
{
if(val > p->data)
p = p->right;
else if(val < p->data)
p = p->left;
else if(val == p->data)
{

removeNode(p);
return;
}
}
}
void clear(Node*node)
{
if(node->left != NULL)
clear(node->left);
if(node->right != NULL)
clear(node->right);

delete node;
node = NULL;
}
void print(Node *node)
{
if(node == NULL)
return;
cout<<node->data<< " ";
if(node->left != NULL)
print(node->left);
if(node->right != NULL)
print(node->right);
}
void insert(T val)
{
insert(root,val);
}
void print()
{
print(root);
cout<<"\n";
}
};

int main()
{
BinarySearchTree<int> tree;
tree.insert(10);
tree.insert(1);
tree.insert(11);
tree.insert(9);
tree.insert(8);
tree.print();
cout<<"\n\n";
tree.remove(9);
tree.print();

return 0;
}