二叉树的递归和非递归实现前序中序后序遍历

今天看到这里，整理一下树的遍历

主要说一下后序遍历的特性（非递归）：访问某个节点时，栈中保存的元素正好是这个节点的所有祖先。

可以解决的问题：

• 给定一个叶子节点，要求输出该叶子节点的所有祖先
• 输出根节点到所有叶子节点的路径
• 如果二叉树节点的值是数值，那么求每条路径上值之和，也可以利用二叉树后序遍历的非递归算法

上代码：

#include<bits/stdc++.h>
using namespace std;

static int num = 1;

struct TreeNode
{
    TreeNode()
    {
        left = nullptr;
        right = nullptr;
        val = num++;
    }
    TreeNode *left,*right;
    int val;
};

void preorder_digui(TreeNode* node)
{
    if(node == nullptr)
        return;

    cout<<node->val<<" ";
    preorder_digui(node->left);
    preorder_digui(node->right);

    return;
}

void inorder_digui(TreeNode* node)
{
    if(node == nullptr)
        return;

    inorder_digui(node->left);
    cout<<node->val<<" ";
    inorder_digui(node->right);

    return;
}

void postorder_digui(TreeNode* node)
{
    if(node == nullptr)
        return;

    postorder_digui(node->left);
    postorder_digui(node->right);
    cout<<node->val<<" ";

    return;
}

void preorder_feidigui(TreeNode* node)
{
    stack<TreeNode*>s;
    s.push(node);
    while(!s.empty())
    {
        TreeNode *x = s.top();
        s.pop();
        cout<<x->val<<" ";
        if(x->right != nullptr)
            s.push(x->right);
        if(x->left != nullptr)
            s.push(x->left);
    }
    cout<<endl;
}

void inorder_feidigui(TreeNode* node)
{
    stack<TreeNode*>s;
    TreeNode *p = node;
    while(!s.empty() || p)
    {
        if(p != nullptr)
        {
            s.push(p);
            p = p->left;
        }
        else
        {
            TreeNode *x = s.top();
            s.pop();
            cout<<x->val<<" ";
            p = x->right;
        }
    }
    cout<<endl;
}

void postorder_feidigui_normal(TreeNode *node)
{
    stack<TreeNode*> s;
    TreeNode *current = node;
    TreeNode *previsited = nullptr;
    while(!s.empty() || current)
    {
        if(current != nullptr)
        {
            s.push(current);
            current = current->left;
        }
        else
        {
            current = s.top();
            if(current->right == nullptr || current->right == previsited)
            {
                cout<<current->val<<" ";
                previsited = current;
                s.pop();
                current = nullptr;
            }
            else
            {
                current = current->right;
            }
        }
    }
    cout<<endl;
}

void postorder_feidigui_twostack(TreeNode *node)
{
    stack<TreeNode *>s1, s2;
    s1.push(node);
    while(!s1.empty())
    {
        TreeNode *x = s1.top();
        s1.pop();
        s2.push(x);
        if(x->left != nullptr)
            s1.push(x->left);
        if(x->right != nullptr)
            s1.push(x->right);
    }
    while(!s2.empty())
    {
        cout<<s2.top()->val<<" ";
        s2.pop();
    }
    cout<<endl;
}

int main()
{
    TreeNode *root = new TreeNode();
    root->left = new TreeNode();
    root->right = new TreeNode();
    root->left->left = new TreeNode();
  //  root->left->right = new TreeNode();
    root->right->left = new TreeNode();
    root->right->right = new TreeNode();
    cout<<"preorder_digui："<<endl;
    preorder_digui(root);
    cout<<endl;
    cout<<"inorder_digui: "<<endl;
    inorder_digui(root);
    cout<<endl;
    cout<<"postorder_digui: "<<endl;
    postorder_digui(root);
    cout<<endl;
    cout<<"preorder_feidigui:"<<endl;
    preorder_feidigui(root);
    cout<<"inorder_feidigui:"<<endl;
    inorder_feidigui(root);
    cout<<"postorder_feidigui_normal:"<<endl;
    postorder_feidigui_normal(root);
    cout<<"postorder_feidigui_twostack:"<<endl;
    postorder_feidigui_twostack(root);
}