#pragma once
template<class Type>
class BSTree;
template<class Type>
class BSTNode
{
friend class BSTree<Type>;
public:
BSTNode() :data(0), leftChild(NULL), rightChild(NULL) {}
BSTNode(Type d) :data(d), leftChild(NULL), rightChild(NULL) {}
~BSTNode() {}
public:;
void Setdata(Type d)
{
data = d;
}
Type GetData()const
{
return data;
}
public:
Type data;
BSTNode<Type>*leftChild;
BSTNode<Type>*rightChild;
};
template<class Type>
class BSTree
{
public:
BSTree() :root(NULL) {}
BSTree(Type ar[], int n) :root(NULL)
{
for (int i = 0; i < n; i++)
insert(ar[i]);
}
~BSTree()
{
MakeEmpty(root);
}
public:
bool insert(Type&x)
{
return insert(root, x);
}
void sort()
{
sort(root);
}
bool remove(const Type&key)
{
return remove(root, key);
}
Type Max()const
{
return Max(root)->data;
}
Type Min()const
{
return Min(root)->data;
}
BSTNode<Type>*Find(Type key)
{
return Find(root, key);
}
Type Parent(Type t)const
{
BSTNode<Type>*p = Parent(root, t);
if (p != NULL)
return p->data;
else
return -1;
}
void MakeEmpty(BSTNode<Type>*&t)
{
if (t != NULL)
{
MakeEmpty(t->leftChild);
MakeEmpty(t->rightChild);
delete t;
t = NULL;
}
}
public:
BSTNode<Type>*Min(BSTNode<Type>*root)const
{
while (root->leftChild != NULL)
root = root->leftChild;
return root;
}
BSTNode<Type>*Max(BSTNode<Type>*root)const
{
while (root->rightChild != NULL)
root = root->rightChild;
return root;
}
BSTNode<Type>*Find(BSTNode<Type>*root, Type&key)
{
if (root != NULL)
{
if (root->data == key)
return root;
else if (root->data > key)
Find(root->rightChild, key);
else if (root->data < key)
Find(root->leftChild, key);
}
return false;
}
BSTNode<Type>*Parent(BSTNode<Type>*t, Type val)const
{
if (t == NULL || t->data == val)
return NULL;
else if (t->leftChild != NULL&&t->leftChild->data == val)
return t;
else if (t->rightChild != NULL&&t->rightChild->data == val)
return t;
else if (t->data > val)
Parent(t->leftChild, val);
else
Parent(t->rightChild, val);
}
public:
bool remove(BSTNode<Type>*&t, const Type &key)
{
if (t != NULL)
{
if (key < t->data)//在左子树中删除
remove(t->leftChild, key);
else if (key > t->data)//在右子树中删除
remove(t->rightChild, key);
else
{
/*if (t->leftChild == NULL&&t->rightChild == NULL)//左右子树都为空
{
delete t;
t = NULL;
}
else if (t->leftChild != NULL&&t->rightChild == NULL)//左不空,右空
{
BSTNode<Type>*tmp = t;
t = t->leftChild;
return tmp;
}
else if (t->leftChild == NULL&&t->rightChild != NULL)//右空,左不空
{
BSTNode<Type>*tmp = t;
t = t->rightChild;
return tmp;
}*/
//左右子树都不空
if (t->leftChild == NULL&&t->rightChild != NULL)
{
BSTNode<Type>*tmp = t->leftChild;
while (tmp->rightChild != NULL)
tmp = tmp->rightChild;
t->data = tmp->data;
remove(t->leftChild, t->data);
}
//他有一个或零个子女
else
{
BSTNode<Type>*tmp = t;
if (t->leftChild == NULL)
t = t->rightChild;
else
t = t->leftChild;
delete tmp;
}
return true;
}
}
return false;
}
void sort(BSTNode<Type>*t)const
{
if (t != NULL)
{
sort(t->leftChild);
cout << t->data << " ";
sort(t->rightChild);
}
}
bool insert(BSTNode<Type>*&t,Type&x)const
{
if (t == NULL)
{
t = new BSTNode<Type>(x);
return true;
}
else if (x < t->data)
insert(t->leftChild, x);
else if (x > t->data)
insert(t->rightChild, x);
else
return false;
}
private:
BSTNode<Type>*root;
};
void main()
{
int ar[] = { 53,78,65,17,87,9,81,45,23,68 };
int n = sizeof(ar) / sizeof(int);
BSTree<int> bst(ar, n);
bst.sort();
cout << endl;
cout << bst.Parent(78) << endl;
cout<<bst.Max()<<endl;
cout<<bst.Min()<<endl;
BSTNode<int>*p = NULL;
if (p = bst.Find(53))
cout << p->data << endl;
else
cout << "not find" << endl;
bst.remove(87);
bst.sort();
//bst.~BSTree();
//bst.sort();
}