二叉树的三种遍历，递归和非递归

 递归转非递归，用到了栈的前进后出的特点，使得保存当前函数的状态

前序遍历，每次的操作：从根节点向左遍历，每次使用栈进行存储，直到空指针，则指向该结点的有孩子

中序遍历，每次的操作：从根节点向左遍历，每次使用栈进行存储，直到空指针，则指向该结点的有孩子

后序遍历，每次的操作：从根节点向左遍历，每次使用栈进行存储，直到空指针，输出的时候判断该节点如果没有右孩子或者右子树被访问过了，则可以输出该子树的根节点了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <stack>

using namespace std;

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

TreeNode *tree;

void CreateTree(TreeNode* &tree) {
    char data;
    cin >> data;
    if(data == '#') {
        tree = NULL;
    }
    else {
        tree = new TreeNode;
        if(tree == NULL) return;
        tree->val = data;
        CreateTree(tree->left);
        CreateTree(tree->right);
    }
}

void Recursion_PreOrder(TreeNode* tree) {
    if(tree == NULL) {
        return;
    }
    else {
        cout << tree->val << " ";
        Recursion_PreOrder(tree->left);
        Recursion_PreOrder(tree->right);
    }
}

void PreOrder(TreeNode* tree) {
    stack<TreeNode*> s;
    TreeNode *tmp = tree;
    if(tree == NULL) {
        return;
    }
    else {
       while(tmp != NULL || !s.empty()) {
            while(tmp != NULL) {
                cout << tmp->val << " ";
                s.push(tmp);
                tmp = tmp->left;
            }
            if(!s.empty()) {
                tmp = s.top();
                tmp = tmp->right;
                s.pop();
            }
       }
    }
}

void Recursion_InOrder(TreeNode* tree) {
    if(tree == NULL) {
        return;
    }
    else {
        Recursion_InOrder(tree->left);
        cout << tree->val << " ";
        Recursion_InOrder(tree->right);
    }
}


void InOrder(TreeNode* tree) {
    stack<TreeNode*> s;
    TreeNode *tmp = tree;

    if(tree == NULL) {
        return;
    }
    else {
        while(tmp != NULL || !s.empty()) {
            while(tmp !=NULL) {
                s.push(tmp);
                tmp = tmp->left;
            }
            if(!s.empty()) {
                cout << s.top()->val << " ";
                tmp = s.top()->right;
                s.pop();
            }
        }
    }
}


void Recursion_PostOrder(TreeNode* tree) {
    if(tree == NULL) {
        return;
    }
    else
    {
        Recursion_PostOrder(tree->left);
        Recursion_PostOrder(tree->right);
        cout << tree->val << " ";
    }
}


void PostOrder(TreeNode* tree) {
    stack<TreeNode*> s;
    TreeNode *tmp = tree; // present pointer
    TreeNode *pre = NULL; //previous node pointer
    if(tree == NULL) {
        return;
    }
    else
    {
        while(tmp != NULL || !s.empty()) {
            while(tmp != NULL) {
                s.push(tmp);
                tmp = tmp->left;
            }

            if(!s.empty()) {
                TreeNode *node = s.top();
                s.pop();
                if(node->right == NULL || node->right == pre) {
                    cout << node->val << " ";
                    pre = node;
                } else {
                    s.push(node);
                    tmp = node->right;
                }
            }
        }
    }
}

int main() {
    CreateTree(tree);
    cout << "PreOrder:\n";
    PreOrder(tree);
    cout << "\n";

    cout << "InOrder:\n";
    InOrder(tree);
    cout << "\n";

    cout << "PostOrder:\n";
    PostOrder(tree);
    cout << "\n";
    /*
    cout << "PreOrder:\n";
    Recursion_PreOrder(tree);
    cout << "\n";

    cout << "InOrder:\n";
    Recursion_InOrder(tree);
    cout << "\n";

    cout << "PostOrder:\n";
    Recursion_PostOrder(tree);
    cout << "\n";
    */
    return 0;
}

测试数据: 123##4##5##(前序的赋值格式)