Dada uma árvore N-ária, retorne o percurso pós-pedido de seus valores de nó.
Método 1: método recursivo para resolver diretamente:
/*
// Definition for a Node.
class Node {
public:
int val;
vector<Node*> children;
Node() {}
Node(int _val) {
val = _val;
}
Node(int _val, vector<Node*> _children) {
val = _val;
children = _children;
}
};
*/
class Solution {
public:
vector<int> postorder(Node* root) {
if (root == nullptr) {
return {
};
}
size_t sz = root->children.size();
vector<int> res;
for (size_t i = 0; i < sz; ++i) {
vector<int> fromChild = postorder(root->children[i]);
res.insert(res.end(), fromChild.begin(), fromChild.end());
}
res.push_back(root->val);
return res;
}
};
Método 2: Método recursivo: use a pilha para percorrer a árvore inteira. Sempre que um nó for percorrido, armazene o nó na matriz de resultado, em seguida, coloque seus nós filhos na pilha da esquerda para a direita, repita este processo e, finalmente, inverta o array de resultados. pode:
/*
// Definition for a Node.
class Node {
public:
int val;
vector<Node*> children;
Node() {}
Node(int _val) {
val = _val;
}
Node(int _val, vector<Node*> _children) {
val = _val;
children = _children;
}
};
*/
class Solution {
public:
vector<int> postorder(Node* root) {
if (root == nullptr) {
return {
};
}
vector<int> ret;
stack<Node *> stk;
stk.push(root);
Node *cur = stk.top();
while (!stk.empty()) {
cur = stk.top();
ret.push_back(cur->val);
stk.pop();
for (Node *n : cur->children) {
stk.push(n);
}
}
reverse(ret.begin(), ret.end());
return ret;
}
};