Iterative postorder

//Iterative postorder

import java.util.LinkedList;
import java.util.Queue;
import java.io.*;
import java.util.*;

class Node {
    int data;
    Node left;
    Node right;
    Node(int data) {
        this.data = data;
        left = null;
        right = null;
    }
}

class GfG {

    static Node buildTree(String str) {
        if(str.length() == 0 || str.charAt(0) == 'N') {
            return null;
        }

        String ip[] = str.split(" ");
        Node root = new Node(Integer.parseInt(ip[0]));
        Queue<Node> queue = new LinkedList<>();

        queue.add(root);

        int i = 1;

        while (queue.size() > 0 && i < ip.length) {
            Node currNode = queue.peek();
            queue.remove();
            String currVal = ip[i];

            if(!currVal.equals("N")) {
                currNode.left = new Node(Integer.parseInt(currVal));
                queue.add(currNode.left);
            }

            i++;

            if(i >= ip.length) {
              break;
            }

            currVal = ip[i];

            if(!currVal.equals("N")) {
                currNode.right = new Node(Integer.parseInt(currVal));
                queue.add(currNode.right);
            }

            i++;
        }

        return root;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());

        while(t > 0) {
            String s = br.readLine();
            Node root = buildTree(s);
            Tree g = new Tree();
            ArrayList<Integer> res = g.postOrder(root);

            for(int i = 0; i < res.size(); i++) {
                System.out.print(res.get(i) + " ");
            }
            System.out.print("\n");

            t--;
        }
    }
}

class Node{
    int data;
    Node left;
    Node right;
    Node(int data){
        this.data = data;
        left=null;
        right=null;
    }
}

class Tree {
    ArrayList<Integer> postOrder(Node node) {
        ArrayList<Integer> post = new ArrayList<>();

        if(node == null) {
            return post;
        }

        Stack<Node> st = new Stack<>();
        Node cur = node;

        while(cur != null || !st.isEmpty()) {
            if(cur != null) {
                st.push(cur);
                cur = cur.left;
            }
            else {
                Node temp = st.peek().right;

                if(temp == null) {
                    temp = st.pop();
                    post.add(temp.data);

                    while(!st.isEmpty() && temp == st.peek().right) {
                        temp = st.pop();
                        post.add(temp.data);
                    }
                }
                else {
                    cur = temp;
                }
            }
        }

        return post;
    }
}