二叉查找树_前序遍历_中序_后序_递归与非递归写法_层次遍历_以及树形显示

#include <iostream>
#include <stack>
using namespace std;

template<typename T>
struct BinaryNode
{
T element;
BinaryNode<T> *left;
BinaryNode<T> *right;

BinaryNode(const T &theElement, BinaryNode *lt, BinaryNode *rt)
: element(theElement), left(lt), right(rt) {}
};

template<typename T>
class BinarySearchTree
{
public:
BinarySearchTree() {
root = nullptr;
}
BinarySearchTree(const BinarySearchTree& rhs) {  //复制构造函数
root = clone(rhs.root);
}
~BinarySearchTree();

const T &findMin() const {
return findMin(root)->element;
}
const T &findMax() const {
return findMax(root)->element;
}

bool contains(const T& x) const;
T& getNode(const T& e) {                        //得到元素为e的结点
return getNode(e, root)->element;
}

bool isEmpty() const {
if (root == nullptr)
return true;
return false;
}
void PreprintTree() const {
PreprintTree(root);
}

void InprintTree() const {
InprintTree(root);
}

void PostprintTree() const {
PostprintTree(root);
}

void LevelprintTree() const {
LevelprintTree(root);
}

void PreprintTree_N() const {
PreprintTree_N(root);
}

void InprintTree_N() const {
InprintTree_N(root);
}

void PostprintTree_N() const {
PostprintTree_N(root);
}

void DisplayTreeShape(int level = 1) const {
DisplayTreeShape(root, level);
}

void makeEmpty();
void insert(const T &x);
void remove(const T &x);
int Depth();
int CountLeaf() {
BinaryNode<T> *p = root;
int count = 0;
CountLeaf(p, count);
return count;
}

const BinarySearchTree& operator = (const BinarySearchTree& rhs);

private:

BinaryNode<T> *root;                      //指向树根结点的指针

void insert(const T & x, BinaryNode<T> * & t);
void remove(const T & x, BinaryNode<T> * & t);
BinaryNode<T> * findMin(BinaryNode<T> *t) const;
BinaryNode<T> * findMax(BinaryNode<T> *t ) const;

bool contains(const T & x, BinaryNode<T> *t) const;
BinaryNode<T> * getNode(const T &x, BinaryNode<T> *t);

void makeEmpty( BinaryNode<T> * & t );
//利用 递归 算法 计算树的 深度
int Depth( BinaryNode<T> * t, int level, int &depth);
//利用 递归 算法 计算树的 高度
void CountLeaf(BinaryNode<T> * t, int &count);

void PreprintTree( BinaryNode<T> * t ) const;           //先序遍历
void InprintTree( BinaryNode<T> *t ) const;             //中序遍历
void PostprintTree( BinaryNode<T> * t ) const;          //后序遍历
void LevelprintTree( BinaryNode<T> * t) const;          //层次遍历

void PreprintTree_N( BinaryNode<T> * t) const;          //非递归先序遍历
void InprintTree_N( BinaryNode<T> * t) const;           //非递归中序遍历二叉树
void PostprintTree_N( BinaryNode<T> * t) const;         //非递归后序遍历二叉树
void DisplayTreeShape(BinaryNode<T> *bt, int level) const;    //二叉树的树形显示算法

BinaryNode<T> * clone( BinaryNode<T> * t ) const;
};

template<typename T>
bool BinarySearchTree<T>::contains(const T& x) const
{
return contains(x, root);
}

template<typename T>
bool BinarySearchTree<T>::contains(const T & x, BinaryNode<T> *t) const
{
if (t == nullptr)
return false;
else if (x < t->element)          // x 小， 说明应该在左边找
return contains(x, t->left);
else if (t->element < x)          // x 大， 说明应该在右面找
return contains(x, t->right);
else
return true;
}

template<typename T>
BinaryNode<T>* BinarySearchTree<T>::getNode(const T & x, BinaryNode<T> *t)
{
if (t == nullptr)
return nullptr;
else if (x < t->element)
return getNode(x, t->left);
else if (t->element < x)
return getNode(x, t->right);
return t;
}

//findMin--返回指向树中包含最小元的结点的指针
template<typename T>
BinaryNode<T> * BinarySearchTree<T>::findMin(BinaryNode<T> *t) const
{
if (t == nullptr)
return  nullptr;
if (t->left == nullptr)
return t;
return findMin(t->left);
}

template<typename T>
BinaryNode<T>* BinarySearchTree<T>::findMax(BinaryNode<T> *t) const
{
if (t != nullptr)
while (t->right != nullptr) {
t = t->right;
}
return t;
}

template<typename T>
void BinarySearchTree<T>::insert(const T &x)
{
insert(x, root);
}

/************************************************************************/
/* x is the item to insert        */
/* t is the node that roots the subtree*/
/* Set the new root of the subtree*/
///* 只有当一个新树叶生成时候，t才改变.
///* t 是到p->left或p->right的引用.==> 意味着p->left或p->right将会改变为指向新结点.
/************************************************************************/
template<typename T>
void BinarySearchTree<T>::insert(const T & x, BinaryNode<T> * & t)
{
if (t == nullptr)         //没有结点，在该位置处添加新结点
t = new BinaryNode<T>(x, nullptr, nullptr);
else if (x < t->element)  //x 小， 在左子树查询
insert(x, t->left);
else if (t->element < x)  //x 大， 在右子树查询
insert(x, t->right);
else;                     //Duplicate, do nothing;
}

template<typename T>
void BinarySearchTree<T>::remove(const T &x)
{
remove(x, root);
}

/************************************************************************/
/* x is item to remove                                                  */
/* t is the node that roots the subtree                                 */
/* Set the new root of the subtree                                      */
/* 1.结点是一片树叶时 -- 可被立即删除*/
/* 2.结点有一个儿子, 则该结点可以在其父节点调整他的链 以绕过该结点后被删除 */
/* 3.结点有两个儿子, 则其右子树的最小数据代替该结点的数据，并递归删除那个结点 */
/* 注: 右子树中的最小的结点不可能有左结点                               */
/************************************************************************/
template<typename T>
void BinarySearchTree<T>::remove(const T &x, BinaryNode<T> * & t)
{
if (t == nullptr) return;     //Item not found; do nothing
if (x < t->element)           //x 小，在左子树递归查找
remove(x, t->left);
else if (t->element < x)      //x 大，在右子树递归查找
remove(x, t->right);
else if (t->left != nullptr && t->right != nullptr)  //two children
{
//在右子树中查找最小数据代替该结点数据.;
t->element = findMin(t->right)->element;
remove(t->element, t->right);                    //删除该结点
}
else                         //只有一个结点或是树叶. 调整它的链,以绕过该结点后被删除.
{
BinaryNode<T> *oldNode = t;
t = (t->left != nullptr) ? t->left : t->right;
delete oldNode;
}
}

/************************************************************************/
///* Destructor for the tree
/************************************************************************/
template<typename T>
BinarySearchTree<T>::~BinarySearchTree()
{
makeEmpty();
}

template<typename T>
void BinarySearchTree<T>::makeEmpty()       //公有函数
{
makeEmpty(root);
}

/************************************************************************/
///* Internal method to make subtree empty -- 私有函数
/************************************************************************/
template<typename T>
void BinarySearchTree<T>::makeEmpty(BinaryNode<T> * & t)
{
if (t != nullptr)
{
makeEmpty(t->left);
makeEmpty(t->right);
delete t;
}
t = nullptr;
}

/************************************************************************/
///* Deep copy
/************************************************************************/
template<typename T>
const BinarySearchTree<T>& BinarySearchTree<T>::operator = (const BinarySearchTree &rhs)
{
if (this != &rhs) {
makeEmpty();
root = clone(rhs.root);
}
return *this;
}

/************************************************************************/
///* Internal method to clone subtree.  --  递归复制结点
/************************************************************************/
template<typename T>
BinaryNode<T>* BinarySearchTree<T>::clone(BinaryNode<T> * t) const
{
if (t == nullptr)
return nullptr;
return new BinaryNode<T>( t->element, clone(t->left), clone(t->right) );
}

//利用递归计算树的深度
template<typename T>
int BinarySearchTree<T>::Depth()
{
BinaryNode<T> *t = root;
int depth = 0;
if (root == nullptr)
return 0;
Depth(t, 1, depth);
return depth;
}

//由public的函数Depth调用, 完成树的深度的计算，p是根结点，Level是层，depth用来返回树的深度
template<typename T>
int BinarySearchTree<T>::Depth(BinaryNode<T> *t, int level, int &depth)
{
if (level > depth) depth = level;                  //层数
if (t->left) Depth(t->left, level + 1, depth);     //递归遍历左子树，且层数加1
if (t->right) Depth(t->right, level + 1, depth);   //递归遍历右子树, 且层数加1
return 0;
}

template<typename T>
//利用 递归 算法 计算树的 高度
void BinarySearchTree<T>::CountLeaf(BinaryNode<T> * t, int &count)
{
if (t == nullptr) return;               //为空时，退出

//    CountLeaf(t->left, count);
//    CountLeaf(t->right, count);
if (!(t->left) && !(t->right)) {        //儿子为空时
count++;
}
CountLeaf(t->left, count);
CountLeaf(t->right, count);
}

/************************************************************************/
///* printTree   ---    前序遍历
/************************************************************************/
template<typename T>
void BinarySearchTree<T>::PreprintTree(BinaryNode<T> * t) const
{
if (t != nullptr) {
cout << t->element << ' ';
PreprintTree(t->left);
PreprintTree(t->right);
}
}

//中序遍历
template<typename T>
void BinarySearchTree<T>::InprintTree(BinaryNode<T> * t ) const
{
if (t != nullptr) {
InprintTree(t->left);
cout << t->element << ' ';
InprintTree(t->right);
}
}

//后序遍历
template<typename T>
void BinarySearchTree<T>::PostprintTree(BinaryNode<T> * t) const
{
if (t != nullptr) {
PostprintTree(t->left);
PostprintTree(t->right);
cout << t->element << ' ';
}
}

//利用队列Queue层次遍历二叉树
template<typename T>
void BinarySearchTree<T>::LevelprintTree( BinaryNode<T> * t) const
{
const int maxn = 1024;
BinaryNode<T> *Queue[maxn];                          //一维数组作为队列
BinaryNode<T> *tmp;
int front = 0, rear = 0;                             //队列初始为空
if (root) {
Queue[rear++] = root;                            //二叉树的根结点指针入队列
while (front != rear)
{
tmp = Queue[front++];                        //队首的元素出队列
if (tmp) cout << tmp->element << ' ';        //输出结点值
if (tmp->left) Queue[rear++] = tmp->left;
if (tmp->right) Queue[rear++] = tmp->right;
}
}
}

//先序遍历
template<typename T>
void BinarySearchTree<T>::PreprintTree_N( BinaryNode<T> * t) const          //非递归先序遍历
{
const int maxn = 1024;
BinaryNode<T> *Stack[maxn];
int top = 0;
BinaryNode<T> *tmp = root;            //将根结点的指针赋值给tmp

//    cout << "Debug :\n";
while (tmp || top != 0)
{
//        cout << "debug : \n";
while (tmp) {
cout << tmp->element << ' ';
Stack[top++] = tmp;           //右孩子入栈
tmp = tmp->left;              //一直递归到最左的结点
}
if (top) {                        //栈不为空, 从栈中取出一个结点指针
tmp = Stack[--top];
tmp = tmp->right;
}
}
}

//中序非递归遍历二叉树 (LDR)
template<typename T>
void BinarySearchTree<T>::InprintTree_N( BinaryNode<T> * t) const           //非递归中序遍历二叉树
{
const int maxn = 1024;
BinaryNode<T> *Stack[maxn];
int top = 0;
BinaryNode<T> *tmp = root;

while (tmp || top != 0)
{
while (tmp) {                  //迭代到最左的子树
Stack[top++] = tmp;        //左子树入栈
tmp = tmp->left;
}
if (top) {
tmp = Stack[--top];            //出栈最左的子树
cout << tmp->element << ' ';   //输出该元素
tmp = tmp->right;              //并指向右结点开始迭代
}
}

}

//非递归后序遍历二叉树 (LRD)
template<typename T>
void BinarySearchTree<T>::PostprintTree_N( BinaryNode<T> * t) const
{
const int maxn = 1024;
struct Mystack {
BinaryNode<T> * link;
int flag;
};

Mystack Stack[maxn];
BinaryNode<T> * p = root, *tmp;

if (root == nullptr) return;

int top = -1,                  //栈顶初始化
sign = 0;                  //为结点tmp 的标志量

while ( p != nullptr || top != -1)
{
while (p != nullptr)       //遍历到最左
{
Stack[++top].link = p; //并且一直入栈
Stack[top].flag = 1;   //设置flag为第一次入栈
p = p->left;
}

if (top != -1)
{
tmp = Stack[top].link;
sign = Stack[top].flag;
top--;                 //出栈

if (sign == 1)         //结点第一次进栈
{
top++;
Stack[top].link = tmp;
Stack[top].flag = 2;            //标记为第二次出栈
p = tmp->right;
}
else {                 //第二次出栈就输出
cout << tmp->element << ' ';      //访问该结点数据域
p = nullptr;
}
}

}

}

//树形显示二叉树，也是中序遍历
template<typename T>
void BinarySearchTree<T>::DisplayTreeShape(BinaryNode<T> *bt, int level) const
{
if (bt)                                         //二叉树的树形显示算法
{
cout << endl;
for (int i = 0; i < level - 1; i++)
cout << "   ";                            //确保在第level列显示结点
cout << bt->element;                        //显示结点
DisplayTreeShape(bt->left, level - 1);     //空二叉树不显示
//        cout << endl;                               //显示右子树
DisplayTreeShape(bt->right, level + 2);      //显示左子树
}
}

int main()
{
//    srand((unsigned)time(nullptr));
int testData, t = 0;
BinarySearchTree<int> test;
cout << "输入数字个数: \n";
cin >> t;
cout << "输入数字: \n";
while (t--)
{
testData = rand() % 500 + 1;
test.insert(testData);
}
cout << "\n全部元素为: \n";
test.PreprintTree();

cout << endl;
//    cin >> testData;                //不符合查找二叉树
//    test.getNode(testData) = 10000;

cout << "\nMax = " << test.findMax() << endl;
cout << "Min = " << test.findMin() << endl;

cout << "输入查找元素: \n";
cin >> testData;
cout << "是否包含 " << testData  << " : " << test.contains(testData) << endl;
test.PreprintTree();

cout << endl;
cout << "输入删除元素: \n";
cin >> testData;
test.remove(testData);

cout << "\n树的高度: " << test.Depth() << endl;
cout << "\n叶子的个数: " << test.CountLeaf() << endl;
cout << endl;

cout << "先序遍历树元素: \n";
test.PreprintTree();

cout << "\n\n中序遍历树元素: \n";
test.InprintTree();

cout << "\n\n后序遍历树元素: \n";
test.PostprintTree();

cout << "\n\n层次遍历树元素: \n";
test.LevelprintTree();

cout << "\n\n先序遍历树元素(非递归): \n";
test.PreprintTree_N();

cout << "\n\n中序遍历树元素(非递归): \n";
test.InprintTree_N();

cout << "\n\n后序遍历树元素(非递归): \n";
test.PostprintTree_N();

cout << "\n\n二叉树的树形显示算法: \n";
test.DisplayTreeShape(43);

cout << endl;
return 0;
}