leetcode 145

思路一：栈实现

1.假设当前访问以root为根的树，那么访问次序为：root的左子树p1—>root的右子树p2，root节点，对于左子树p1和p2以此类推。这是递归的思想，也是栈实现的核心思想。
2.按照递归的思路，从根节点开始；一直向左遍历，将路径上的节点加入栈空间当中，直到当前节点为空。
3.如果当前节点为空，则从栈空间弹出其父亲节点。
4.
①如果当前节点是父亲节点的左孩子则父亲节点重新入栈，然后开始访问父亲节点的右子树。也就是根节点变成父亲节点的右孩子节点，进入2。
②如果当前空节点为父亲节点的右孩子，则父亲节点出栈，而且此时父亲节点的左右孩子都已经访问过了，所以可以访问父亲节点，然后继续向上返回。此当前节点变成父亲节点，重新进入4。

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        TreeNode* p=root;
        TreeNode* pre=NULL;
        stack<TreeNode*> s;
        vector<int> res;
        while(p||!s.empty())
        {
            while(p)
            {
                s.push(p);
                p=p->left;
            }
            p=s.top();
            s.pop();
            if(p->right==NULL||p->right==pre)
            {
                res.push_back(p->val);
                pre=p;
                p=NULL;
            }
            else
            {
                s.push(p);
                p=p->right;
            }
        }
        return res;
    }
};

思路二：Morris遍历

1.假设当前访问节点为root，其左边子树记为left，右子树记为right，左孩子left_child，右孩子right_child。
2.访问以root为根的左子树过程中是如何返回root节点的呢？
假设当前访问中序遍历root的前驱pre，（也就是left_child一直沿着右孩子节点向右走直到走到一个缺少右孩子的节点），按照后序遍历的规则，也就是从pre沿着父亲节点一直向上访问，直到访问完left_child，然后回到root。
3.访问完left之后，需要访问right，只需要切换根节点root，访问方式同2。
4.以此类推，最后只剩下以root为根节点一直向右走直到pre的路径上所有节点没有访问。此时只需要自下向上访问直到根节点即可。

实现：
1.假设当前访问以p1为根节点的树，p1左孩子记为p2。
2.
①如果p2为空，则p1指向p1的右子树，访问p1的右子树。
②如果p2不为空，则p2沿着右孩子走到p1中序遍历的前驱节点pre。
3.
①如果p2右孩子为空，将p2的右孩子指向p1，p1更新为p1的左子树，访问p1左子树，回到1。
②如果p2右孩子为p1，则沿着从p1左孩子一直向右走走到p2的路径逆序输出节点。
4.p1更新为p1的右孩子。
5.
①如果p1非空，回到1。
②如果p1为空，沿着从root一直向右走走到叶子节点的路径逆序输出节点。

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void reprint(TreeNode* root,vector<int> &res)
    {
        vector<int> t; 
        while(root)
        {
            t.push_back(root->val);
            root=root->right;
        }
        reverse(t.begin(),t.end());
        res.insert(res.end(),t.begin(),t.end());
    }
    vector<int> postorderTraversal(TreeNode* root) {
        TreeNode* p1=root;
        TreeNode* p2=NULL;
        vector<int> res;
        if(!root)
            return res;
        while(p1)
        {
            p2=p1->left;
            if(p2==NULL)
                p1=p1->right;
            else
            {
                while(p2->right&&p2->right!=p1)
                {
                    p2=p2->right;
                }
                if(p2->right==NULL)
                {
                    p2->right=p1;
                    p1=p1->left;
                    continue;
                }
                else
                {
                    p2->right=NULL;
                    reprint(p1->left,res);
                    p1=p1->right;
                }
            }
        }
        reprint(root,res);
        return res;
    }
};