N-ary Tree Level Traversal bug (C++) - c++

Question

I'm doing a coding challange on LeetCode and I'm asked to traverse each level and at the end return a nested vectors with values node values for each values.
So if I have a tree like:
Which is
Input: root = [1,null,3,2,4,null,5,6]
And expected output is
Output: [[1],[3,2,4],[5,6]]
The definition for the Node is as follows:
/*
// 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;
}
};
*/
I'm attempting an iterative solution that is as follows:
class Solution {
public:
vector<vector<int>> answer;
stack<Node*> nodes;
vector<vector<int>> levelOrder(Node* root) {
if(root == NULL)
return answer;
nodes.push(root);
answer.push_back(vector<int>() = {root->val});
while(!nodes.empty())
{
Node* curr = nodes.top();
nodes.pop();
vector<int>temp;
for(int i = 0; i < curr->children.size(); i++)
{
nodes.push(curr->children[i]);
temp.push_back(curr->children[i]->val);
}
if(temp.size() != 0)
answer.push_back(temp);
}
return answer;
}
};
However it consistently fails 20th test case where the input is:
[1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
The expectation is:
[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
My output is
[[1],[2,3,4,5],[9,10],[13],[8],[12],[6,7],[11],[14]]
I'm having trouble visualising and drawing this N-ary tree on paper, so I have a hard time comprehending where my algorithm went wrong.

Answer 1

The problem with your code is that for each node you visit, you append all its children as a new list to the answer list. Your code does not group children on the same level but with different parents into one list, as would be expected by the solution.
Let us step through your code to see what happens:
Before the loop, you push the root node onto the stack and push a singleton set with the root node value to the answer:
stack = {1}
answer = { {1} }
The first iteration pops the 1 from the stack. You then iterate over the children 2,3,4,5, which are pushed on the stack. Afterwards, the list of children is pushed to the answer list.
stack = {2,3,4,5}
answer = { {1}, {2,3,4,5} }
The next iteration pops the 5 from the stack. You then iterate over the children 9, 10. They are pushed onto the stack. Afterwards, the list of children is pushed to the answer list.
stack = {2,3,4,9,10}
answer = { {1}, {2,3,4,5}, {9, 10} }
The next iteration pops the 10 from the stack. It has no children, so nothing happens.
stack = {2,3,4,9}
answer = { {1}, {2,3,4,5}, {9, 10} }
The next iteration pops the 9 from the stack. You then iterate over the single child 13, which is pushed to the stack. A singleton list containing 13 is pushed to the answer set.
stack = {2,3,4}
answer = { {1}, {2,3,4,5}, {9, 10}, {13} }
The next iteration pops the 4 from the stack. You then iterate over the single child 8, which is pushed to the stack. A singleton list containing 8 is pushed to the answer set.
stack = {2,3,8}
answer = { {1}, {2,3,4,5}, {9, 10}, {13}, {8} }
Your can see that your answer list is wrong from here. The 8 is on the same level as 9 and 10, so it should have been added to the {9,10} sub-list in the answer list, instead of creating a new list {8}. This should be sufficient to illustrate the problem, so I will not step through the code further.
To ensure that nodes on the same level are grouped into the same sub-list in the answer list, we have to keep track of the current level when visiting each node. We can do this by extending the stack to hold pairs of the current node and its depth. Each node value at depth d will then be appended to the dth sub-list in the answer list. This ensures that nodes on the same level are grouped into one sub-list.
std::vector<std::vector<int>> get_vals_per_level(const Node *root) {
std::vector<std::vector<int>> vals_per_level{};
std::stack<std::pair<const Node *, int>> stack{};
stack.emplace(root, 0);
while (!stack.empty()) {
auto [current, depth]{stack.top()};
stack.pop();
if (vals_per_level.size() == depth) {
vals_per_level.emplace_back();
}
// Append node value to the answer list for the current depth
vals_per_level[depth].push_back(current->val);
auto& children{current->children};
for (auto it{children.rbegin()}; it != children.rend(); it++) {
stack.emplace(*it, depth + 1);
}
}
return vals_per_level;
}
The code uses structured bindings from C++17.