[Leetcode] Postorder Traverse of Binary Tree

1. Method 1: two stacks 

   /**
    * Definition for binary tree
    * public class TreeNode {
    *     int val;
    *     TreeNode left;
    *     TreeNode right;
    *     TreeNode(int x) { val = x; }
    * }
    */
   public class Solution {
    
       public List<Integer> postorderTraversal(TreeNode root) {
         List<Integer> res = new ArrayList<Integer>(); 
         Stack <TreeNode> s = new Stack<TreeNode>();
         Stack <TreeNode> out = new Stack<TreeNode>();
         if(root ==null) return res; 
         s.push(root);
         while(s.empty() == false){
           TreeNode top = s.pop();
           out.push(top); 
           if(top.left != null)
             s.push(top.left);
           if(top.right != null)
             s.push(top.right);
         }
         while(out.empty() == false){
           res.add(out.pop().val); 
         }
         return res; 
     }
   }

   
   
2. Method 2: use only one stack but two cursors 

   #include <stack>
   
   using namespace std;
   
   class Solution {
   public:
       vector<int> postorderTraversal(TreeNode *root) {
           vector <int> res;
           if (!root) return res;
   
           stack<TreeNode*> s;
           TreeNode* prev = nullptr;
           s.push(root);
   
           while (!s.empty())
           {
               TreeNode* cur = s.top();
   
               //taking into account that if previous element coming from a subtree then it is either direct left or right child
               if (cur->right && cur->right == prev || !cur->right && cur->left == prev || !cur->left && !cur->right)
               {
                   s.pop();
                   res.push_back(cur->val);
                   prev = cur;
                   continue;
               }
   
               if (cur->right) s.push(cur->right);
               if (cur->left) s.push(cur->left);
           }
   
           return res;        
       }
   };