leetcode590 N叉树的后序遍历

• 前序遍历 的顺序是：根 → 子节点1 → 子节点2 → ... → 子节点N

• 后序遍历 的顺序是：子节点1 → 子节点2 → ... → 子节点N → 根

首先一个办法就是前序遍历结果进行翻转

在 迭代法 实现 后序遍历 时，如果采用 前序遍历 + 反转 的方式，经过栈，是反转再反转，我们需要 从右到左 遍历子节点，而 递归法 如果采用 前序遍历 + 反转 的方式，遍历子节点没有又经过栈，从左到右遍历即可。

迭代：

// 子节点从左到右入栈（保证前序顺序）

class Solution {
public:
    vector<int> postorder(Node* root) {
        vector<int> res;
        if(root == NULL) return res;
        stack<Node*> st;
        st.push(root);
        while(!st.empty()){
            Node* cur = st.top();
            st.pop();
            res.push_back(cur->val);
            for(int i = 0; i < cur->children.size(); i++){
            st.push(cur->children[i]);
            }
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

递归：

class Solution {
private:
    void traverse(Node* cur, vector<int>& res){
        if(!cur) return;
        res.push_back(cur->val);
        // 子节点从右到左遍历（保证 reverse 后顺序正确）
        for(int i = cur->children.size() - 1; i >= 0; i--){
            traverse(cur->children[i], res);
        }
    }
public:
    vector<int> postorder(Node* root) {
        vector<int> res;
        traverse(root, res);
        reverse(res.begin(), res.end());
        return res;
    }
};

直接后序遍历（递归）

正确逻辑：先递归所有子节点，再访问根节点。

class Solution {
private:
    void traverse(Node* cur, vector<int>& res){
        if(!cur) return;
        for(Node* child: cur->children){
            traverse(child, res);
        }
        res.push_back(cur->val);
    }
public:
    vector<int> postorder(Node* root) {
        vector<int> res;
        traverse(root, res);
        return res;
    }
};

1. 递归的栈机制：

   • 每次递归调用 traverse(child) 时，当前函数的执行状态（如 node 和循环位置）会被压入调用栈。

   • 当子节点的递归全部完成后，才会回到父节点执行 res.push_back(node->val)。

2. 子节点的处理顺序：

   • 如果子节点按 从左到右 递归，则后序结果是 [左→右→根]。

   • 如果子节点按 从右到左 递归，则后序结果是 [右→左→根]（但仍然符合后序定义，只是子节点顺序不同）。