JAVA versions of Iterative-Tree-Traversal Amazing HACK :)

Author: prashant-kr-314

IterativeTreeTraversal_JAVA_1.java

@@ -0,0 +1,76 @@
+
+// ? =============   USING   HASH-MAP    =============
+
+import java.util.*;
+
+// !    NOTE :  while using this don'toverride the equals()&hashCode()method in Node Class
+
+class Node {
+    int val;
+    Node left, right;
+
+    Node(int val) {
+        this.val = val;
+        left = right = null;
+    }
+}
+
+class IterativeMagic {
+
+    public static void traversalTrick(Node root) { // postorder
+
+        HashMap<Node, Integer> state = new HashMap<Node, Integer>();
+        Stack<Node> s = new Stack<Node>();
+        s.push(root);
+
+        while (!s.empty()) {
+            Node curNode = s.peek();
+
+            if (curNode == null) {
+                s.pop();
+                continue;
+            }
+
+            int curState;
+            if (!state.containsKey(curNode))// if no state exits till now - give it a state 0
+                state.put(curNode, 0);
+
+            curState = state.get(curNode);
+
+            switch (curState) {
+                case 0:
+                    s.push(curNode.left);
+                    break;
+                case 1:
+                    s.push(curNode.right);
+                    break;
+                case 2:
+                    System.out.print(curNode.val + " ");
+                    break;
+                default:
+                    s.pop();
+            }
+
+            state.put(curNode, curState + 1); // change its current state : previous state's task done
+        }
+    }
+
+}
+
+public class IterativeTreeTraversal_JAVA_1 {
+
+    public static void main(String... args) {
+        Node tmp = new Node(7);
+        Node root = tmp;
+
+        root.left = new Node(3);
+        root.right = new Node(10);
+        root.left.left = new Node(2);
+        root.left.right = new Node(5);
+        root.left.left.left = new Node(1);
+        root.right.left = new Node(8);
+        root.right.right = new Node(5);
+
+        IterativeMagic.traversalTrick(tmp);
+    }
+}

IterativeTreeTraversal_JAVA_2.java

@@ -0,0 +1,67 @@
+
+// ? =============   WITHOUT   HASH-MAP    =============
+
+import java.util.*;
+import javafx.util.Pair; //? ***
+
+// !    NOTE :  while using this don'toverride the equals()&hashCode()method in Node Class
+class Node {
+    int val;
+    Node left, right;
+
+    Node(int val) {
+        this.val = val;
+        left = right = null;
+    }
+}
+
+class IterativeMagic {
+
+    public static void traversalTrick(Node root) { // ! inorder
+
+        Stack<Pair<Node, Integer>> s = new Stack<Pair<Node, Integer>>();
+        s.push(new Pair<>(root, 0));
+
+        while (!s.empty()) {
+            Pair<Node, Integer> p = s.pop();
+            Node curNode = p.getKey();
+            int state = p.getValue();
+
+            if (curNode == null || state == 3) {
+                continue;
+            }
+
+            s.push(new Pair<>(curNode, state + 1)); // new State
+
+            switch (state) {
+                case 0:
+                    s.push(new Pair<>(curNode.left, 0));
+                    break;
+                case 1:
+                    System.out.print(curNode.val + " ");
+                    break;
+                case 2:
+                    s.push(new Pair<>(curNode.right, 0));
+                    break;
+            }
+        }
+    }
+}
+
+public class IterativeTreeTraversal_JAVA_2 {
+
+    public static void main(String... args) {
+        Node t = new Node(7);
+        Node root = t;
+
+        t.left = new Node(3);
+        t.right = new Node(10);
+        t.left.left = new Node(2);
+        t.left.right = new Node(5);
+        t.left.left.left = new Node(1);
+        t.right.left = new Node(8);
+        t.right.right = new Node(12);
+
+        IterativeMagic.traversalTrick(root);
+    }
+}