<p>Given the <code>root</code> of a&nbsp;binary tree, return <em>the postorder traversal of its nodes&#39; values</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">root = [1,null,2,3]</span></p>

<p><strong>Output:</strong> <span class="example-io">[3,2,1]</span></p>

<p><strong>Explanation:</strong></p>

<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/29/screenshot-2024-08-29-202743.png" style="width: 200px; height: 264px;" /></p>
</div>

<p><strong class="example">Example 2:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">root = [1,2,3,4,5,null,8,null,null,6,7,9]</span></p>

<p><strong>Output:</strong> <span class="example-io">[4,6,7,5,2,9,8,3,1]</span></p>

<p><strong>Explanation:</strong></p>

<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/29/tree_2.png" style="width: 350px; height: 286px;" /></p>
</div>

<p><strong class="example">Example 3:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">root = []</span></p>

<p><strong>Output:</strong> <span class="example-io">[]</span></p>
</div>

<p><strong class="example">Example 4:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">root = [1]</span></p>

<p><strong>Output:</strong> <span class="example-io">[1]</span></p>
</div>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li>The number of the nodes in the tree is in the range <code>[0, 100]</code>.</li>
	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
</ul>

<p>&nbsp;</p>
<strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

// preorder postorder and inorder together using 1 stack only


tuple<vector<int>,vector<int>,vector<int>> Allorders(TreeNode* root){
    vector<int> preorder,inorder,postorder;
    stack<pair<TreeNode*,int>>st;
    st.push({root,1});
    while(!st.empty()){
        TreeNode* top=st.top().first;
        int num=st.top().second;
        st.pop();
        if(num==1){
            preorder.push_back(top->val);
            st.push({top,2});
            if(top->left)st.push({top->left,1});
        }
        else if(num==2){
            inorder.push_back(top->val);
            st.push({top,3});
            if(top->right)st.push({top->right,1});
        }
        else{
            postorder.push_back(top->val);
        }
    }

tuple<vector<int>,vector<int>,vector<int>>tup={preorder,inorder,postorder};
return tup;
    
}
    vector<int> postorderTraversal(TreeNode* root) {
        if(root==nullptr) return {};
        tuple<vector<int>,vector<int>,vector<int>>tup=Allorders(root);
        vector<int>postorder=get<2>(tup);
        return postorder;
    }
};
10600