非递归实现树的前中后遍历

代码衔接BST树的代码，可以放在一起运行测试

非递归先序：

先根遍历的基本思想就是：输出自己，输出左子树，输出右子树。

从根节点出发，向左依次输出并进栈，当左孩子为空时，指针指向栈顶的右子树， 然后出栈，对右子树进行遍历。

void pre_output_stack(node* root)
{
    stack<node*> s;
    node* p = root;
    
    while (p  || !s.empty())
    {
        while (p)               //先输出，再进栈，一直往左边走
        {
            cout << p->data;
            s.push(p);
            p = p->lch;
        }                       //到了从根节点出发，最左边的节点
        if (!s.empty())         //遍历最左边节点的右子树，且最左节点出站
        {
            p = s.top();
            s.pop();
            p = p->rch;
        }
    }
}

中序遍历：先左子树，在右子树。

明白了中根遍历，先根遍历就很容易理解，从根节点向左边出发，一次出栈保存，到了最左边节点后，记录栈顶t， 出栈输出t，遍历右子树。

void mid_output_stack(node* root)
{
    stack<node*> s;
    node *p = root;
    
    while (p || !s.empty())
    {
        while (p)
        {
            s.push(p);
            p = p->lch;
        }
        if (!s.empty())
        {
            p = s.top();
            s.pop();
            cout << p->data;
            p = p->rch;
        }
    }
}

后序遍历：先一次遍历左右子树，再输出自己。

首先要注意到一个规律，就是后序遍历中如果一个节点右孩子不空，那么一定是先输出右孩子，紧接着是该节点。

所以当遍历完了左子树后，直接看该节点的右孩子，若空，直接输出，若不空，则要看右子树自否输出(没有输出就要继续遍历)，若上一个输出节点是右子树的根节点，那么说明右子树遍历完毕，可以直接输出。

所以相对于前序，中序遍历，后序遍历需要一个标记记录输出节点的前驱节点。

void post_output_stack(node* root)
    node* p = root;
    stack<node*> s;
    node* prev = NULL;
    while (p || !s.empty())
    {
        while (p)  //往左边遍历
        {
            s.push(p);
            p = p->lch;
        }
        if (s.top()->rch == NULL || s.top()->rch == prev)  //若右孩子为空或已遍历，输出并出栈
        {
            cout << s.top()->data;
            prev = s.top();
            s.pop();
        }
        else  //没有遍历就遍历右孩子
        {
            p = s.top()->rch;
        }
    }
}

void per(TreeNode *root)
{
    stack<TreeNode*> s;
    
    if (root)
    {
        s.push(root);
        cout << s.top()->val << " ";
    }

    while (!s.empty())
    {
        while (s.top()->left)
        {
            s.push(s.top()->left);
            cout << s.top()->val << " ";
        }
        
        while (!s.empty() && s.top()->right == nullptr)
        {
            s.pop();
        }
        
        if (!s.empty())
        {
            TreeNode *current = s.top();
            s.pop();
            s.push(current->right);
            cout << s.top()->val << " ";
        }
    }
    putchar(10);
}

void mid(TreeNode* root)
{
    stack<TreeNode*> s;
    
    if (root)
    {
        s.push(root);
    }
    
    while (!s.empty())
    {
        while (!s.empty() && s.top()->left)
        {
            s.push(s.top()->left);
        }
        
        while (!s.empty() && s.top()->right == nullptr)
        {
            cout << s.top()->val << " ";
            s.pop();
        }
        
        if (!s.empty())
        {
            TreeNode *current = s.top();
            cout << s.top()->val << " ";
            s.pop();
            s.push(current->right);
        }
    }
    putchar(10);
}

void post(TreeNode* root)
{
    stack<TreeNode*> s;
    
    if (root)
    {
        s.push(root);
    }
    
    while (!s.empty())
    {
        while (!s.empty() && s.top()->left)
        {
            s.push(s.top()->left);
        }
        
        while (!s.empty() && s.top()->right == nullptr)
        {
            TreeNode *current = s.top();
            cout << s.top()->val << " ";
            s.pop();
            while (!s.empty() && s.top()->right == current)
            {
                current = s.top();
                cout << s.top()->val << " ";
                s.pop();
            }
        }
        
        if (!s.empty())
        {
            s.push(s.top()->right);
        }
    }
    putchar(10);
    
}