c++ binarytree(二叉树)

#pragma once

#include<iostream>
#include<queue>
#include<stack>

using namespace std;

template <class T>  //树的结构体
struct BinaryTreeNode
{
public:
T _data;
BinaryTreeNode<T>* _leftChild;
BinaryTreeNode<T>* _rightChild;

public:
BinaryTreeNode(const T& data)
:_data(data)
, _leftChild(NULL)
, _rightChild(NULL)
{}

~BinaryTreeNode()
{}
};

template <class T>
class BinaryTree //树的封装
{
public:
BinaryTreeNode<T>* _root;

public:
BinaryTree()
:_root(NULL)
{}

BinaryTree( T*a, size_t size)
{
size_t index = 0;
_root = _CreateBiTree(a, index, size);
}

BinaryTree(const BinaryTree& tmp)
:_root(NULL)
{
_root=_Copy(tmp._root);

}
~BinaryTree()
{
Destory();
}

BinaryTree<T>& operator=( BinaryTree<T> tmp)
{
swap(_root, tmp._root);
return *this;

}

void InOrder()//中序遍历递归方法
{
_InOrder(_root);
cout << endl;
}

void PreOrder()//前序遍历递归方法
{
_PreOrder(_root);
cout << endl;
}

void PosOrder()//后序遍历递归方法
{
_PosOrder(_root);
cout << endl;
}

void LevelOrder()//层序遍历
{
queue<BinaryTreeNode<T>*> s ;
s.push(_root);
while (!s.empty())
{
BinaryTreeNode<T>* cur = s.front();
cout<<cur->_data<<' ';
if (cur->_leftChild)
s.push(cur->_leftChild);
if (cur->_rightChild)
s.push(cur->_rightChild);
s.pop();
}
cout << endl;
}

void Size()//节点数
{
int size = 0;
cout<<_Size(_root,size)<<endl;

}

void Hight()//深度  /高度
{
cout << _Hight(_root) << endl;
}

void Destory()//销毁
{
_Destory(_root);
_root=NULL;
}

void LeafNum()//叶子节点数
{
int num = 0;
_LeafNum(_root, num);
cout <<num<<endl;

}

void PreOrderNonR()//前序 非递归  （借用栈）
{
if (_root == NULL)
return;
stack<BinaryTreeNode<T>*> s ;
s.push(_root);
while (!s.empty())
{
BinaryTreeNode<T>* cur;
cur=s.top();
s.pop();
cout << cur->_data << ' ';
if (cur->_rightChild)
s.push(cur->_rightChild);
if (cur->_leftChild)
s.push(cur->_leftChild);
}
cout << endl;
}

void InOrderNonR() //中序 非递归
{
if (_root == NULL)
return;
stack<BinaryTreeNode<T>*> s;
s.push(_root);
BinaryTreeNode<T>* prev=NULL;
BinaryTreeNode<T>* cur=NULL;
while (!s.empty())
{
cur = s.top();
if(prev != cur&&cur->_leftChild) //左不空 压左
{
s.push(cur->_leftChild);
}
else //左空   出栈 输出
{
cout << cur->_data << ' ';
s.pop();
if (!s.empty())
prev = s.top();//prev始终为出栈后的栈顶
if (cur->_rightChild)//  cur右不空  压右
{

s.push(cur->_rightChild);

}
}
}
cout << endl;
}

void PosOrderNonR()  //后续  非递归
{
if (_root == NULL)
return;
stack<BinaryTreeNode<T>*> s;
BinaryTreeNode<T>* cur = NULL;
BinaryTreeNode<T>* prev = NULL;
BinaryTreeNode<T>* tmp = NULL;
s.push(_root);
while (!s.empty())
{
cur = s.top();
if (prev != cur&&cur->_leftChild != NULL)//1.左不空且prev！=cur 压左
s.push(cur->_leftChild);
else//左空
{
if (cur->_rightChild!=tmp  &&cur->_rightChild)//右不空 且 cur->right！=tmp 压右
{
s.push(cur->_rightChild);
}

else             //右空  输出 cur
{
cout << cur->_data << ' ';
tmp = s.top();    //tmp(判断是否压右)始终为出栈前的栈顶
s.pop();
if (!s.empty())
{
prev = s.top();//prev（判断是否压右）始终为出栈后栈顶

}
}
}
}
cout << endl;
}

protected://以下为递归的调用函数

BinaryTreeNode<T>* _CreateBiTree(const T* tmp, size_t& index, size_t size)
{
BinaryTreeNode<T>* root = NULL;
if (index < size&&tmp[index]!='#')
{
root = new BinaryTreeNode<T>(tmp[index]);
root->_leftChild = _CreateBiTree(tmp, ++index, size);
root->_rightChild = _CreateBiTree(tmp, ++index, size);
}
return root;
}

void _InOrder(BinaryTreeNode<T>* &T)
{
if (T == NULL)
return;
_InOrder(T->_leftChild);
cout << T->_data << ' ';
_InOrder(T->_rightChild);
}

void _PreOrder(BinaryTreeNode<T>* &T)
{
if (T == NULL)
return;
cout << T->_data<<' ';
_PreOrder(T->_leftChild);
_PreOrder(T->_rightChild);

}

void _PosOrder(BinaryTreeNode<T>* &T)
{
if (T == NULL)
return;
_PosOrder(T->_leftChild);
_PosOrder(T->_rightChild);
cout << T->_data << ' ';
}

int _Size(BinaryTreeNode<T>* root,int & size)
{
if (root == NULL)
return 0;
size++;
_Size(root->_leftChild, size);
_Size(root->_rightChild, size);
return size;
}

int _Hight(BinaryTreeNode<T>* root)
{
int hight = 1;
if (root == NULL)
return 0;
hight += _Hight(root->_leftChild);
int ritHight = 0;
ritHight+= _Hight(root->_rightChild);
if (hight < ritHight)
hight = ritHight;
return hight;

}
void _Destory(BinaryTreeNode<T>* root)
{
if (root == NULL)
return;
BinaryTreeNode<T>* del = root;

_Destory(del->_leftChild);
_Destory(del->_rightChild);
delete root;

return;
}

void _LeafNum(BinaryTreeNode<T>* root,int& num)
{
if (root == NULL)
return ;
if (root->_leftChild == NULL&&root->_rightChild == NULL)
++num;
_LeafNum(root->_leftChild,num);
_LeafNum(root->_rightChild,num);
return ;
}

BinaryTreeNode<T>* _Copy(BinaryTreeNode<T>* root)
{
if (root == NULL)
return NULL;
BinaryTreeNode<T>* newRoot = NULL;
newRoot = new BinaryTreeNode<T>(root->_data);
newRoot->_leftChild = _Copy(root->_leftChild);
newRoot->_rightChild = _Copy(root->_rightChild);
return newRoot;

}
};

//测试用例

#include"binarytree.hpp"

using namespace std;

void test()
{
int l[10] = { 1, 2, 3,'#', '#', 4, '#', '#', 5, 6 };
int s[18] = { 1, 2, 3, 4, '#', '#', 5, '#', '#', 6,'#','#' ,7, 8, '#', '#', 9, 10 };
BinaryTree<int> t1;
BinaryTree<int> t2(s, 18);
BinaryTree<int> t3(t2);
t1 = t2;
t2.PreOrder();
t2.InOrder();
t2.PosOrder();
t2.LevelOrder();
t2.Size();
t2.Hight();
t2.Destory();
t3.InOrder();
t1.InOrder();
t3.LeafNum();
t3.PreOrderNonR();
t3.InOrderNonR();
t3.PosOrderNonR();
}

int main()
{
test();
return 0;
}