二叉树的非递归遍历

#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <stack>
#include <unordered_map>
#include <map>
#include <algorithm>
using namespace std;

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

//以前序遍历创建二叉树
void CreateBiTree(TreeNode **T)//*T是指向BiTNode的指针
{
    *T = new TreeNode(0);
    if (*T == NULL)//如果*T还是指向NULL，表示内存分配失败，退出程序
        exit(OVERFLOW);
    char ch;
    cin >> ch;
    if (ch == '#')
        *T = NULL;
    else
    {
        (*T)->val = ch;//*T指向的节点的data分配内容，即生成根节点
        CreateBiTree(&((*T)->left));//创建&(*T)->lchild临时变量，传入CreateBiTree，构造左子树
        CreateBiTree(&((*T)->right));//创建&(*T)->rchild临时变量，传入CreateBiTree，构造右子树
    }
}

//非递归前序遍历
//不需要先进入到左根部，所以先访问父节点，再push右孩子入栈，再push左孩子入栈
vector<char> preorderTraversal(TreeNode* root) {
    vector<char> result;
    stack<TreeNode*> s;
    if (root == NULL)
        return result;
    s.push(root);
    while (!s.empty()) {
        TreeNode* p = s.top();
        s.pop();
        result.push_back(p->val);//访问父节点
        if (p->right)//把父节点的右孩子入栈
            s.push(p->right);
        if (p->left)//把父节点的左孩子入栈
            s.push(p->left);
    }
    return result;
}

//非递归中序遍历
//需要先进入到左孩子的最末端，直到左孩子为空，则访问该节点，再访问该节点的右孩子
vector<char> inorderTraversal(TreeNode* root) {
    vector<char> result;
    stack<TreeNode*> s;
    if (root == NULL)
        return result;
    TreeNode* p = root;
    while (!s.empty() || p != NULL) {
        if (p != NULL) {
            //push非空节点和它的左孩子入栈
            s.push(p);
            p = p->left;
        }
        else {
            //访问该节点，然后访问右子树
            p = s.top();
            result.push_back(p->val);
            s.pop();
            p = p->right;
        }
    }
    return result;
}

//非递归后序遍历
//用一个遍历记录刚刚访问过的节点，如果当前要访问的节点的右子树刚刚已经访问过了，才可以访问当前节点
//否则如果如果是第一次访问该节点，如果重新入栈
vector<char> postorderTraversal(TreeNode* root) {
    vector<char> result;
    if (root == NULL)
        return result;
    stack<TreeNode*> s;
    TreeNode* p = root;  //当前正访问的节点
    TreeNode* q;  //记录刚刚访问过的节点
    do {//把该节点的左孩子入栈，直到某节点没有左孩子
        while (p != NULL) {
            s.push(p);
            p = p->left;
        }
        q = NULL;
        while (!s.empty()) {
            p = s.top();
            s.pop();
            if (p->right == q) {  //当右子树已经访问过了，才可以访问根
                result.push_back(p->val);
                q = p;  //记录刚刚访问过的节点
            }
            else {
                s.push(p); //第一次访问到该节点，需要将它重新入栈
                p = p->right;
                break;
            }

        }
    } while (!s.empty());
    return result;
}

//打印vector
void print(vector<char> v)
{
    for (int i = 0;i < v.size();i++)
        cout << v[i];
}

//测试
int main()
{
    TreeNode **pp;//定义指向BiTNode的二级指针pp
    TreeNode *p;//定义指向BiTNode的指针p
    pp = &p;//pp指向p
    p = NULL;//初始化p指向NULL
    CreateBiTree(pp);//传入指向p的地址，创建二叉树,输入ABD##E##CF##G##

    vector<char> preorder;
    vector<char> inorder;
    vector<char> postorder;
    preorder = preorderTraversal(p);
    inorder = inorderTraversal(p);
    postorder = postorderTraversal(p);

    cout << "非递归前序遍历" << endl;
    print(preorder);
    cout << endl;
    cout << "非递归中序遍历" << endl;
    print(inorder);
    cout << endl;
    cout << "非递归后序遍历" << endl;
    print(postorder);
    cout << endl;
    return 0;
}