Why do I need to push the right node before the left node during iterative solution to pre-order traversal when it's supposed to be left before right? - binary-tree

Question

To solve this leetcode question :
Binary tree pre order traversal
It is good to remember that pre-order traversal traverses a tree in the order of
root->left->right.
In light of this, if I write an iterative solution to the problem above following the order of insertion of root, left and right, my solution does not pass all the hidden test cases.
To understand this, below is the code that does not pass all the hidden test cases:
public List<Integer> preorderTraversal(TreeNode root) {
//preOrder means root comes before other traversals therefore root,left,right
List<Integer> finalListToReturn = new ArrayList();
if(root == null)
return finalListToReturn;
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.push(root); //add root first
while(!stack.isEmpty()){
TreeNode node = stack.pop();
finalListToReturn.add(node.val); //add to list
//left must be traversed before the right,this is the natural order for preOrder
if(node.left != null)
stack.push(node.left);
if(node.right != null)
stack.push(node.right);
}
return finalListToReturn;
}
but the above code will not pass all hidden testcases when I submit.
However, if i traverse right node before left, all testcases pass, why is that so ?
For context,this is the snippet that passes all hidden test cases when submited.
public List<Integer> preorderTraversal(TreeNode root) {
//preOrder means root comes before other traversals therefore root,left,right
List<Integer> finalListToReturn = new ArrayList();
if(root == null)
return finalListToReturn;
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.push(root); //add root first
while(!stack.isEmpty()){
TreeNode node = stack.pop();
finalListToReturn.add(node.val); //add to list
//once right is traversed first before left, then every test case passes,why is that so?
if(node.right != null)
stack.push(node.right);
if(node.left != null)
stack.push(node.left);
}
return finalListToReturn;
}
Why is it that the first code snippet which traverses a binary search tree in the right pre-order route(root->left->right) rather does not pass all test cases but when the same code is tweaked to traverse in the order of (root->right->left) in the second snippet,all test cases pass? Can someone explain why?

Answer 1

So basically, if you look carefully, we are using a stack.
Observe the while loop we are using critically and you'll realize that we do pop(ie return the item at the top), and in this case, a Stack follows the LIFO principle, that is , the last element in,becomes the first element to come out during a pop.
Now after we add our node.val to finalListToReturn inside the while loop, if we add the left element first and then push the right element, what it means is that , during the next iteration, the last element that entered, the right element, will be popped first since a stack follows LIFO.
Obviously, we don't want that, so we will rather push the right element first and then the left element. Now during the next pop, the left element will pop first before the right, which is what we were looking for originally.
Thus, our final code should be exactly like the second snippet above:
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> finalListToReturn = new ArrayList();
if(root == null)
return finalListToReturn;
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.push(root);
while(!stack.isEmpty()){
TreeNode node = stack.pop();
finalListToReturn.add(node.val);
if(node.right != null)
stack.push(node.right);
if(node.left != null)
stack.push(node.left);
}
return finalListToReturn;
}