[leetcode] Binary Tree Postorder Traversal

Binary Tree Postorder Traversal

使用递归

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
private:
    vector<int> res;
public:
    vector<int> postorderTraversal(TreeNode *root) {
        if (root!=NULL) {
            postorderTraversal(root->left);
            postorderTraversal(root->right);
            res.push_back(root->val);
        }
        return res;
    }
};

非递归

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
private:
    vector<int> res;
public:
    vector<int> postorderTraversal(TreeNode *root) {
        if (root==NULL) {
            return res;
        }
        stack<TreeNode*> stk;
        stk.push(root);

        TreeNode *cur;
        TreeNode *pre=NULL;
        
        while (!stk.empty()) {
            cur=stk.top();
            if ((cur->left==NULL&&cur->right==NULL)||(pre!=NULL&&(pre==cur->left||pre==cur->right))) {
                res.push_back(cur->val);
                stk.pop();
                pre=cur;
            }else{
                if (cur->right!=NULL) {
                    stk.push(cur->right);
                }
                if (cur->left!=NULL) {
                    stk.push(cur->left);
                }
            }
            
        }
        return res;
    }
};

非递归2：堆栈模拟

#include <iostream>
#include <vector>
#include <stack>
#include <list>
using namespace std;

/**
 * Definition for binary tree */
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
private:
    vector<int> res;
public:
    vector<int> postorderTraversal(TreeNode *root) {
        if (root==NULL) {
            return res;
        }
        stack<TreeNode*> stk;
        stk.push(root);
        while (!stk.empty()) {
            TreeNode *tmp=stk.top();
            res.push_back(tmp->val);
            stk.pop();
            if (tmp->left!=NULL) {
                stk.push(tmp->left);
            }
            if (tmp->right!=NULL) {
                stk.push(tmp->right);
            }
        }
        reverse(res.begin(), res.end());//反序（根-右-左——>左-右-根）
        return res;
    }
};

通用模板：

class Solution {
private:
    vector<int> res;
    stack<TreeNode*> stk;
public:
    vector<int> postorderTraversal(TreeNode *root) {
        if (root==NULL) {
            return res;
        }
        stk.push(root);
        while (!stk.empty()) {
            TreeNode *tmp=stk.top();
            if (tmp->left==NULL&&tmp->right==NULL) {
                stk.pop();
                res.push_back(tmp->val);
            }else{
                stk.pop();//调整下面入栈顺序，即可实现先序、中序、后序遍历
                stk.push(tmp);
                if (tmp->right!=NULL) {
                    stk.push(tmp->right);
                }
                
                if (tmp->left!=NULL) {
                    stk.push(tmp->left);
                }
                tmp->left=tmp->right=NULL;
            }
            
        }
        return res;
    }
};

参考：

二叉树的非递归遍历