#include <iostream>
using namespace std;
template <typename T>
struct BSTNode
{
T val;
BSTNode<T>* lchild;
BSTNode<T>* rchild;
BSTNode<T>* parent;
BSTNode(T t)
: val(t), lchild(NULL), rchild(NULL){}
BSTNode() = default;
};
template <typename T>
class BSTree
{
private:
BSTNode<T>* root; //根节点
private:
BSTNode<T>* search(BSTNode<T>* & p, T key);
void remove(BSTNode<T>* p, T key);
void preOrder(BSTNode<T>* p);
void inOrder(BSTNode<T>* p);
void postOrder(BSTNode<T>* p);
T search_min(BSTNode<T>* p);
T search_max(BSTNode<T>* p);
void destory(BSTNode<T>* &p);
public:
BSTree();
~BSTree();
void preOrder();
void inOrder();
void lastOrder();
void layerOrder();
BSTNode<T>* search1(T key);
BSTNode<T>* search2(T key);
T search_min();
T search_max();
BSTNode<T>* successor (BSTNode<T>* x);
BSTNode<T>* predecessor(BSTNode<T>* x);
void insert(T key);
void remove(T key);
void destory();
void print();
};
template <typename T>
BSTree<T>::BSTree() :root(NULL){}; //构造函数
template <typename T>
BSTree<T>::~BSTree()
{
destory(root);
};
template <typename T>
void BSTree<T>::insert(T key) //插入函数
{
BSTNode<T>* par = NULL;
BSTNode<T>* pnode = root;
while (pnode != NULL) //找到key应该插入的位置,并用par记录其双亲
{
par = pnode;
if (key > pnode->value)
pnode = pnode->rchild;
else if (key < pnode->value)
pnode = pnode->lchild;
else
break;
}
pnode = new BSTNode<T>(key); //创建新节点,插入到双亲节点相应的子节点
if (par == NULL){
root = pnode;
}
else{
if (key > par->value){
par->rchild = pnode;
}
else
par->lchild = pnode;
}
pnode->parent = par;
};
template <typename T>
BSTNode<T>* BSTree<T>::search1(T key) //迭代搜索
{
BSTNode<T> * pnode = root;
while (pnode != NULL) //左右比较,依次往下进行
{
if (key == pnode->value)
return pnode;
if (key > pnode->value)
pnode = pnode->rchild;
else
pnode = pnode->lchild;
}
return NULL;
};
template <typename T>
BSTNode<T>* BSTree<T>::search2(T key) //递归搜索
{
return search(root, key);
};
template <typename T>
BSTNode<T>* BSTree<T>::search(BSTNode<T>* & pnode, T key) //递归搜索
{
if (pnode == NULL)
return NULL;
if (pnode->value == key)
return pnode;
if (key > pnode->value)
return search(pnode->rchild, key);
return search(pnode->lchild, key);
};
template <typename T>
void BSTree<T>::remove(T key) //删除结点
{
remove(root, key);
};
template <typename T>
void BSTree<T>::remove(BSTNode<T>* pnode, T key) //删除点有三种情况,讨论如下
{
if (pnode != NULL)
{
if (pnode->value == key)
{
BSTNode<T>* pdel=NULL;
if (pnode->lchild == NULL || pnode->rchild == NULL)
pdel = pnode; //情况二、三:被删节点只有左子树或右子树,或没有孩子
else
pdel = predecessor(pnode); //情况一:被删节点同时有左右子树,则删除该节点的前驱
BSTNode<T>* pchild=NULL;
if (pdel->lchild != NULL)
pchild = pdel->lchild;
else
pchild = pdel->rchild;
if (pchild != NULL) //让孩子指向被删除节点的父节点
pchild->parent = pdel->parent;
if (pdel->parent == NULL)
root = pchild;
else if (pdel->parent->lchild==pdel)
{
pdel->parent->lchild = pchild;
}
else
{
pdel->parent->rchild = pchild;
}
if (pnode->value != pdel->value)
pnode->value = pdel->value;
delete pdel;
}
//进行递归删除
else if (key > pnode->value)
{
remove(pnode->rchild, key);
}
else remove(pnode->lchild, key);
}
};
template <typename T>
BSTNode<T>* BSTree<T>::predecessor(BSTNode<T>* pnode)
{
if (pnode->lchild != NULL)
{
pnode = pnode->lchild;
while (pnode->rchild != NULL)
{
pnode = pnode->rchild;
}
return pnode;
}
BSTNode<T>* par = pnode->parent;
while (par != NULL && par->lchild == pnode)
{
pnode = par;
par = par->parent;
}
return par;
};
/*
* 给定一棵二叉搜索树中的一个结点,
* 有时需要按中序遍历的次序查找它的后继。
* 如果所有的关键字互不相同,
* 则一个结点xx的后继是大于x.key的最小关键字的结点。
* 一棵二叉搜索树的结构允许我们通过没有任何关键字的比较来确定一个结点的后继。
* 如果后继存在,SUCCESSOR过程将返回一棵二叉搜索树中的结点xx的后继;
* 如果xx是这棵树中的最大关键字元素,则返回null
*/
template <typename T>
BSTNode<T>* BSTree<T>::successor(BSTNode<T>* pnode)
{
if (pnode->rchild != NULL)
{
pnode = pnode->rchild;
while (pnode->lchild != NULL)
{
pnode = pnode->lchild;
}
return pnode;
}
BSTNode<T>* par = pnode->parent;
while (par!=NULL&& par->rchild == pnode)
{
pnode = par;
par = par->parent;
}
return par;
};
template <typename T>
void BSTree<T>::preOrder()
{
preOrder(root);
};
template <typename T>
void BSTree<T>::preOrder(BSTNode<T> *p)
{
if (p != NULL)
{
cout << p->value << endl;
preOrder(p->lchild);
preOrder(p->rchild);
}
};
template <typename T>
void BSTree<T>::inOrder()
{
inOrder(root);
};
template<typename T>
void BSTree<T>::inOrder(BSTNode<T>* p)
{
if (p != NULL)
{
inOrder(p->lchild);
cout << p->value << endl;
inOrder(p->rchild);
}
};
template <typename T>
void BSTree<T>::lastOrder()
{
postOrder(root);
};
template <typename T>
void BSTree<T>::postOrder(BSTNode<T>* p)
{
if (p != NULL)
{
postOrder(p->lchild);
postOrder(p->rchild);
cout << p->value<<endl;
}
};
template <typename T>
T BSTree<T>::search_min()
{
return search_min(root);
};
template <typename T>
T BSTree<T>::search_min(BSTNode<T>* p)
{
if (p->lchild != NULL)
return search_min(p->lchild);
return p->value;
};
template <typename T>
T BSTree<T>::search_max()
{
return search_max(root);
};
template <typename T>
T BSTree<T>::search_max(BSTNode<T>*p)
{
if (p->rchild != NULL)
return search_max(p->rchild);
return p->value;
};
template<typename T>
void BSTree<T>::destory()
{
destory(root);
};
template <typename T>
void BSTree<T>::destory(BSTNode<T>* &p)
{
if (p != NULL)
{
if (p->lchild != NULL)
destory(p->lchild);
if (p->rchild != NULL)
destory(p->rchild);
delete p;
p = NULL;
}
};