要准备面试了，最近才开始看些往年的笔试，面试题，今晚就写一篇最基础的二叉查找树的遍历总结吧。
先序遍历： 先根，再左子树，最后右子树；
中序遍历： 先左子树，再根，最后右子树；
后序遍历： 先左子树， 再右子树，最后根；
以上的每种遍历方式都对应有两种写法：递归与非递归；
仅拿先序遍历的非递归方式来说（其余两种遍历类似）
两者共同点： 对节点的遍历次序一致；
区别：（先序遍历）在非递归调用中，对右子树的遍历在左子树后，先将右子树节点入栈，再将左子树节点入栈，这样在出栈进行遍历的时候起到先遍历左子树，再遍历右子树的效果。 而在递归调用中，先调用左子树的遍历函数，再调用右子树的遍历函数，起到的效果是一致的。
中序遍历的非递归方式：
考虑到先左，再根，后右的顺序，借用栈来实现的时候，应该是：
每次沿左子树的路径走，把路径上的结点依次入栈直到某个结点没有左子，然后该结点出栈，同时将该结点指向其右子，再重复……
后序遍历的非递归方式：
我的做法是对树取反，即左子权值 > 根权值 >
右子权值， 对该反树先序遍历的序列取反即是原来树的后序遍历。我只需要在先序遍历的非递归方式中把左右入栈的顺序改变即可，同时新开一个O(n)的栈来保存要输出的遍历序列。（其他方法我还未想到）
下面是我的代码，在必要的地方都有注释，希望自己能对new，delete，析构函数，构造函数等越来越熟悉。
#include <cstdio>
#include <cstdlib>
#include <stack>
using namespace std;
struct Node{
int value;
Node *Left, *Right;
// Node(){}
Node(int value_){ /// 构造函数；
value= value_;
Left= Right= NULL;
}
~Node(){ /// 析构函数，用于在程序运行结束后释放内存，养成良好的编程习惯；
if( Left ){
delete Left;
Left= NULL;
}
if( Right ){
delete Right;
Right= NULL;
}
}
};
/*----- 开辟新的结点，返回该结点地址 -----*/
/*
Node *NewNode(int value){
Node *p = new Node; //Node *p= (Node *)malloc( sizeof( Node ) );
p->value= value;
p->Left= p->Right= NULL;
return p;
}*/
/*----- 插入新的节点， 返回根结点的地址root -----*/
Node *Insert(int value, Node *root){
if( root==NULL ){
Node *p= new Node( value ); /// new:1、分配足够内存，2、调用构造函数初始化；
return p;
}
Node *p= root, *fp;
while( p ){
fp= p;
if( p->value > value ) p= p->Left;
else p= p->Right;
}
p= new Node( value );
if( fp->value > value ) fp->Left= p;
else fp->Right= p;
return root;
}
/*
共同点：两者对节点的遍历次序一致
区别：在非递归调用中，对右子树的访问在左子树后面，所以先将右子树节点压栈，
再压左子树节点,这样在出栈进行遍历的时候起到先遍历左子树，再遍历右子树的效果。
在递归调用中，对左右子树调用的先后区别在于是先调用左子树的遍历函数，
再调用右子树的遍历函数，起到的效果是一致的。
*/
/*----- 非递归方式先序遍历 -----*/
void Preorder_Travel_No_Recursion(Node *root){
if( root == NULL ) return;
stack<Node *> ss;
ss.push( root );
while( !ss.empty() ){
root= ss.top(); /// .top()： 取栈顶元素；
ss.pop(); /// .pop(): 弹出栈顶元素；
printf("%d ", root->value);
if( root->Right ) ss.push( root->Right ); /// 先将右子结点入栈，保证是先序遍历；
if( root->Left ) ss.push( root->Left );
}
}
/*----- 递归方式先序遍历 -----*/
void Preorder_Travel(Node *root){
if( root ){
printf("%d ", root->value);
Preorder_Travel( root->Left );
Preorder_Travel( root->Right );
}
}
/*----- 非递归方式中序遍历 -----*/
void Inorder_Travel_No_Recursion(Node *root){
if( root == NULL ) return;
stack<Node *> ss;
while( !ss.empty() || root ){ /// 2个结束条件；
while( root ){
ss.push( root );
root= root->Left;
}
root= ss.top();
ss.pop();
printf("%d ", root->value );
root= root->Right;
}
}
/*----- 递归方式中序遍历 -----*/
void Inorder_Travel(Node *root){
if( root ){
Inorder_Travel( root->Left );
printf("%d ", root->value);
Inorder_Travel( root->Right );
}
}
/*----- 递归方式后序遍历 -----*/
void Postorder_Travel(Node *root){
if( root ){
Postorder_Travel( root->Left );
Postorder_Travel( root->Right );
printf("%d ", root->value);
}
}
/*----- 非递归方式后序遍历 -----*/
void Postorder_Travel_No_Recursion(Node *root){
if( root == NULL ) return;
stack<Node *> ss;
stack<int> out;
ss.push( root );
while( !ss.empty() ){
root= ss.top();
ss.pop();
out.push( root->value );
if( root->Left ) ss.push( root->Left );
if( root->Right ) ss.push( root->Right );
}
while( !out.empty() ){
printf("%d ", out.top() );
out.pop();
}
}
int main(){
int a[]={5,2,7,1,8,9,3,4,6};
int n= sizeof(a)/sizeof(*a);
Node *root= NULL;
for(int i=0; i<n; ++i){
root= Insert( a[i], root );
}
printf("先序遍历（递归）： ");
Preorder_Travel( root );
puts("");
printf("先序遍历（非递归）：");
Preorder_Travel_No_Recursion( root );
puts("");
printf("中序遍历（递归）： ");
Inorder_Travel( root );
puts("");
printf("中序遍历（非递归）：");
Inorder_Travel_No_Recursion( root );
puts("");
printf("后序遍历（递归）： ");
Postorder_Travel( root );
puts("");
printf("后序遍历（非递归）：");
Postorder_Travel_No_Recursion( root );
puts("\n");
}