二叉樹的前序、中序、後續遍歷，遞歸、非遞歸實現

前序遍歷遞歸：

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

struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

void pre_order_recursive(TreeNode* root, vector<int>& result) {
	if(!root) return;
	result.push_back(root->val);
	if(root->left)
		pre_order_recursive(root->left, result);
	if (root->right)
		pre_order_recursive(root->right, result);
}


/*
	   1
	  /  \
	 2    3
	/ \  / \
       4  5 6   7
*/
int main(){
	TreeNode* n1 = new TreeNode(1);
	TreeNode* n2 = new TreeNode(2);
	TreeNode* n3 = new TreeNode(3);
	TreeNode* n4 = new TreeNode(4);
	TreeNode* n5 = new TreeNode(5);
	TreeNode* n6 = new TreeNode(6);
	TreeNode* n7 = new TreeNode(7);

	n1->left = n2; n1->right = n3;
	n2->left = n4; n2->right = n5;
	n3->left = n6; n3->right = n7;

	vector<int> res;
	pre_order_recursive(n1, res);
	for(int i = 0; i < res.size(); i++){
		cout << res[i] << " ";
	}
	system("PAUSE");
}

中序遍歷遞歸

void in_order_recursive(TreeNode* root, vector<int>& result) {
	if(root->left)
		in_order_recursive(root->left, result);
	if(root)
		result.push_back(root->val);
	if(root->right)
		in_order_recursive(root->right, result);
}

後續遍歷遞歸

void post_order_recursive(TreeNode* root, vector<int>& result) {
	if(root->left)
		post_order_recursive(root->left, result);
	if(root->right)
		post_order_recursive(root->right, result);
	if(root)
		result.push_back(root->val);
}

前序遍歷非遞歸

void pre_order(TreeNode* root, vector<int>& result) {
	stack<TreeNode*> st;
	while(root || !st.empty()){
		while (root){
			st.push(root);
			result.push_back(root->val);
			root = root->left;
		}
		if(!st.empty()){
			root = st.top();
			st.pop();
			root = root->right;
		}
	}
}

中序遍歷非遞歸

void in_order(TreeNode* root, vector<int>& result) {
	stack<TreeNode*> st;
	while(root || !st.empty()){
		while (root){
			st.push(root);
			root = root->left;
		}
		if(!st.empty()){
			root = st.top();
			result.push_back(root->val);
			st.pop();
			root = root->right;
		}
	}
}

後續遍歷非遞歸（增加指針指向上個遍歷的節點，注意棧的push順序與前序、中序不同）

void post_order(TreeNode* root, vector<int>& result) {
	stack<TreeNode*> st;
	TreeNode* pre = NULL;
	st.push(root);
	while(!st.empty()){
		root = st.top();
		if((root->left == NULL && root->right == NULL) || (pre == root->right) || (root->right == NULL && pre == root->left)){
			result.push_back(root->val);
			cout << root->val << " ";
			pre = root;
			st.pop();
		}
		else{
			if(root->right)
				st.push(root->right);
			if(root->left)
				st.push(root->left);
		}
	}
}

（轉）另一種方式（每個節點增加訪問次數標識，push順序與之前一致）

void postOrder2(BinTree *root)    //非遞歸後序遍歷
{
    stack<BTNode*> s;
    BinTree *p=root;
    BTNode *temp;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)              //沿左子樹一直往下搜索，直至出現沒有左子樹的結點 
        {
            BTNode *btn=(BTNode *)malloc(sizeof(BTNode));
            btn->btnode=p;
            btn->isFirst=true;
            s.push(btn);
            p=p->lchild;
        }
        if(!s.empty())
        {
            temp=s.top();
            s.pop();
            if(temp->isFirst==true)     //表示是第一次出現在棧頂 
             {
                temp->isFirst=false;
                s.push(temp);
                p=temp->btnode->rchild;    
            }
            else                        //第二次出現在棧頂 
             {
                cout<<temp->btnode->data<<" ";
                p=NULL;
            }
        }
    }    
}