二叉树前序，中序，后序的遍历【递归(借用栈实现)和非递归】

#include<iostream>
#include<cassert>
#include<stack>
using namespace std;
template<class T>
struct TreeNode
{
T data;
TreeNode<T>* left;
TreeNode<T>* right;
TreeNode(const T& x)
:data(x)
,left(NULL)
,right(NULL)
{}
};
template<class T>
class BinaryTree
{
typedef TreeNode<T> Node;
public:
BinaryTree(const T* arr,int sz,const T& invalib)//1.构造函数---前序构造二叉树
{
assert(arr);
int index=0;
_root=CreatTree(arr,sz,invalib,index);
}
~BinaryTree()//2.析构函数
{
Destroy(_root);//销毁一颗二叉树
_root=NULL;
}
void PreOrder()//6.前序遍历打印（递归）
{
_PreOrder(_root);
}
void InOrder()//7.中序遍历打印（递归）
{
_InOrder(_root);
}
void EndOrder()//8.后序遍历打印（递归）
{
_EndOrder(_root);
}
void PreOrderNO()//10.前序遍历打印（非递归）
{
_PreOrder(_root);
}
void InOrderNO()//11.中序遍历打印（非递归）
{
_InOrderNO(_root);
}
void EndOrderNO()//12.后序遍历打印（非递归）
{
_EndOrderNO(_root);
}
protected:
Node* CreatTree(const T* arr,int sz,const T& invalib,int& index)//前序构造二叉树
{
assert(arr);
Node* root=NULL;
while (index<sz&&arr[index]!=invalib)
{
root=new Node(arr[index]);
root->left=CreatTree(arr,sz,invalib,++index);//此处index必须前置++
root->right=CreatTree(arr,sz,invalib,++index);//此处index必须前置++
}
return root;
}
void Destroy(Node* root)//销毁一颗二叉树
{
//1.树为空，直接返回，无结点销毁
if (root==NULL)
{
return ;
}
//2.树只有一个结点，则销毁该节点
if (root->left==NULL&&root->right==NULL)
{
delete root;
root=NULL;
return;
}
//3.树的结点大于一个，则先销毁左子树，后销毁右子树
Destroy(root->left);
Destroy(root->right);
delete root;
root=NULL;
}

----------

void _PreOrder(Node* root)//前序遍历打印（递归）：根->左->右
{
//1.根结点为空，二叉树为空，直接返回---递归返回条件
if (root==NULL)
{
return ;
}

//2.根结点不为空,先打印根结点，在打印左子树，后打印右子树
cout<<root->data<<" ";
_PreOrder(root->left);
_PreOrder(root->right);
}

----------

void _InOrder(Node* root)//中序遍历打印（递归）:左->根->右
{
//1.根结为空，二叉树没有结点---递归返回条件
if (root==NULL)
{
return ;
}
//2.根结点不为空，二叉树有节点
_InOrder(root->left);
cout<<root->data<<" ";
_InOrder(root->right);
}

----------

void _EndOrder(Node* root)//后序遍历打印（递归）:左->右->根
{
//1.根结点为空，二叉树没有结点---递归返回条件
if (root==NULL)
{
return ;
}
//2.根结点不为空，二叉树有节点
_EndOrder(root->left);
_EndOrder(root->right);
cout<<root->data<<" ";
}

----------

void _PreOrderNO(Node* root)//前序遍历打印（非递归）---用栈实现(根左右)
{
stack<Node*>  s;
Node* cur=root;
while (cur||!s.empty())
{
while (cur)
{
s.push(cur);
cout<<cur->data<<" ";
cur=cur->left;
}
//top从栈中取出来，表示以这个结点为根结点的树的左子树已经访问完了，
//剩余右子树还没有访问，循环子问题访问右树
Node* top=s.top();
s.pop();
//子问题的方式访问右树
cur=top->right;
}
}

----------

void _InOrderNO(Node* root)//中序遍历打印（非递归）---用栈实现（左根右）
{
stack<Node*> s;
Node* cur=root;
while (cur||!s.empty())
{
while (cur)
{
s.push(cur);
cur=cur->left;
}
Node* top=s.top();
cout<<top->data<<" ";
//表示左子树和根结点已经访问完了，剩下右子树没有访问，循环子问题访问右树
s.pop();
//循环子问题访问右树
cur=top->right;
}
}

----------

void _EndOrderNO(Node* root)//后序遍历打印（非递归）---用栈实现（左右根）
{
stack<Node*>  s;
Node* cur=root;
Node* prev=NULL;//记录已经访问过的结点
while (cur||!s.empty())
{
while (cur)
{
s.push(cur);
cur=cur->left;
}
Node* top=s.top();
//如果该根结点的右子树已经访问过了或者右子树为空，那么直接访问该根结点，
//然后更新prev，从栈中pop掉该节点
if (prev==top->right||top->right==NULL)
{
cout<<top->data<<" ";
s.pop();
prev=top;
}
如果该根结点的右子树没有访问过了或者右子树为不为空
循环更新cur，循环子问题访问右子树
else
{
cur=top->right;
}

}
}
protected:
Node* _root;
};

int main()
{
int arr[]={1,2,3,'#','#',4,'#','#',5,6,'#','#','#'};
int sz=sizeof(arr)/sizeof(arr[0]);
BinaryTree<int>  bt(arr,sz,'#');

cout<<"前序打印【递归】";
bt.PreOrder();
cout<<endl;

cout<<"中序打印【递归】";
bt.InOrder();
cout<<endl;

cout<<"后序打印【递归】";
bt.EndOrder();
cout<<endl;

cout<<"前序打印【非递归】";
bt.PreOrderNO();
cout<<endl;

cout<<"中序打印【非递归】";
bt.InOrderNO();
cout<<endl;

cout<<"后序打印【非递归】";
bt.EndOrderNO();
cout<<endl;
return 0;
}