From b1abf44566fc863d1191847753b551b8c0fe676d Mon Sep 17 00:00:00 2001
From: Ebtisam Jelani <93232997+Ebtisam0402@users.noreply.github.com>
Date: Thu, 12 Feb 2026 14:49:42 -0800
Subject: [PATCH 1/3] recursive using tree node

---
 src/Traversal.java | 42 ++++++++++++++++++++++++++++++++++++++++++
 src/TreeNode.java  | 11 +++++++++++
 2 files changed, 53 insertions(+)

diff --git a/src/Traversal.java b/src/Traversal.java
index 8da0f79..140a98c 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,5 +1,47 @@
 public class Traversal {
   public static void main(String[] args) {
+    TreeNode root = new TreeNode(10, null, null);
+    root.left = new TreeNode(9, null,null);
+    root.left.left = new TreeNode(5, null,null);
+    root.left.right = new TreeNode(2, null,null);
+
+    root.right = new TreeNode(15, null, null);
+    root.right.left = new TreeNode(-3, null, null);
+    root.right.right = new TreeNode(5, null, null);
+    root.right.right.right = new TreeNode(22, null, null);
+
+
+    //preorder(root);
+    //postorder(root);
+    inorder(root);
+  }
+  // Print a tree rooted at the given node in pre-order
+  public static void preorder(TreeNode node){
+    //if null, return
+    if(node == null) return;
+    //print value
+    System.out.println(node.value);
+    //traverse left to recursion and tree works
+    preorder(node.left);
+    //traverse right
+    preorder(node.right);
+
+  }
+
+  public static void postorder(TreeNode node){
+    if(node == null) return;
+     postorder(node.left);
+     postorder(node.right);
+     // print after recursion
+    System.out.println(node.value);
+  }
+
+  public static void inorder(TreeNode node){
+    if(node == null) return;
+    inorder(node.left);
+    System.out.println(node.value);
+    inorder(node.right);
+
 
   }
 }
diff --git a/src/TreeNode.java b/src/TreeNode.java
index acd9639..15718dd 100644
--- a/src/TreeNode.java
+++ b/src/TreeNode.java
@@ -1,4 +1,15 @@
 public class TreeNode {
+    public int value;
+    public TreeNode left;
+    public TreeNode right;
+
+
+    public TreeNode (int value, TreeNode left, TreeNode right){
+        this.value = value;
+        this.left = left;
+        this.right= right;
+
+    }
 
   
 }
\ No newline at end of file

From 3da8b1f2cb56b7bf25e005ccb529063dd007656f Mon Sep 17 00:00:00 2001
From: Ebtisam Jelani <93232997+Ebtisam0402@users.noreply.github.com>
Date: Tue, 17 Feb 2026 14:40:06 -0800
Subject: [PATCH 2/3] added a new live code

---
 src/Traversal.java | 62 +++++++++++++++++++++++++++++++++++++---------
 src/TreeNode.java  | 10 ++++----
 2 files changed, 55 insertions(+), 17 deletions(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index 140a98c..51cb41d 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,22 +1,60 @@
 public class Traversal {
   public static void main(String[] args) {
-    TreeNode root = new TreeNode(10, null, null);
-    root.left = new TreeNode(9, null,null);
-    root.left.left = new TreeNode(5, null,null);
-    root.left.right = new TreeNode(2, null,null);
+    TreeNode<Integer> root = new TreeNode <Integer> (10, null, null);
+    root.left = new TreeNode <Integer> (9, null,null);
+    root.left.left = new TreeNode<Integer> (5, null,null);
+    root.left.right = new TreeNode <Integer> (2, null,null);
 
-    root.right = new TreeNode(15, null, null);
-    root.right.left = new TreeNode(-3, null, null);
-    root.right.right = new TreeNode(5, null, null);
-    root.right.right.right = new TreeNode(22, null, null);
+    root.right = new TreeNode <Integer> (15, null, null);
+    root.right.left = new TreeNode <Integer> (-3, null, null);
+    root.right.right = new TreeNode <Integer> (5, null, null);
+    root.right.right.right = new TreeNode <Integer> (22, null, null);
+
+
+    TreeNode <String> stringRoot = new TreeNode<String> ("Hello", null, null);
+    stringRoot.left = new TreeNode <String> ("how", null,null);
+    stringRoot.left.left = new TreeNode<String> ("are", null,null);
+    stringRoot.left.right = new TreeNode <String> ("you", null,null);
+
+    stringRoot.right = new TreeNode <String> ("I", null, null);
+    stringRoot.right.left = new TreeNode <String> ("am", null, null);
+    stringRoot.right.right = new TreeNode <String> ("so", null, null);
+    stringRoot.right.right.right = new TreeNode <String> ("good", null, null);
 
 
     //preorder(root);
     //postorder(root);
-    inorder(root);
+    //inorder(root);
+
+    //printGreater(root, 4);
+    System.out.println(countNodes(root));
+
+
+  }
+
+  public static int countNodes(TreeNode<?> node) {
+    //if(node == null) return 0;
+    return node == null ? 0: countNodes(node.left) + countNodes(node.right) + 1;
+    // int leftCount = countNodes(node.left);
+    // int rightCount = countNodes(node.right);
+    // int overallCount = leftCount + rightCount + 1;
+
+    // return overallCount;
+
   }
+
+  public static void printGreater(TreeNode<Integer> node, int threshold) {
+    if(node == null) return;
+    if(node.value > threshold) {
+      System.out.println(node.value);
+    }
+    printGreater(node.left, threshold);
+    printGreater(node.right, threshold);
+ }
+
+
   // Print a tree rooted at the given node in pre-order
-  public static void preorder(TreeNode node){
+  public static void preorder(TreeNode<?> node){
     //if null, return
     if(node == null) return;
     //print value
@@ -28,7 +66,7 @@ public static void preorder(TreeNode node){
 
   }
 
-  public static void postorder(TreeNode node){
+  public static <T> void postorder(TreeNode<T> node){
     if(node == null) return;
      postorder(node.left);
      postorder(node.right);
@@ -36,7 +74,7 @@ public static void postorder(TreeNode node){
     System.out.println(node.value);
   }
 
-  public static void inorder(TreeNode node){
+  public static <E> void inorder(TreeNode <E> node){
     if(node == null) return;
     inorder(node.left);
     System.out.println(node.value);
diff --git a/src/TreeNode.java b/src/TreeNode.java
index 15718dd..9c088e6 100644
--- a/src/TreeNode.java
+++ b/src/TreeNode.java
@@ -1,10 +1,10 @@
-public class TreeNode {
-    public int value;
-    public TreeNode left;
-    public TreeNode right;
+public class TreeNode <T> {
+    public T value;
+    public TreeNode <T>left;
+    public TreeNode <T>right;
 
 
-    public TreeNode (int value, TreeNode left, TreeNode right){
+    public TreeNode (T value, TreeNode<T> left, TreeNode<T> right){
         this.value = value;
         this.left = left;
         this.right= right;

From ebe88341cb964effa1ceedfc2f0ebb768811aaa7 Mon Sep 17 00:00:00 2001
From: Ebtisam Jelani <93232997+Ebtisam0402@users.noreply.github.com>
Date: Tue, 24 Feb 2026 14:53:38 -0800
Subject: [PATCH 3/3] levelOrder iterative and preOrder

---
 src/Traversal.java | 114 +++++++++++++++++++++++++++++++++++++++------
 1 file changed, 100 insertions(+), 14 deletions(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index 51cb41d..d4499d3 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,3 +1,9 @@
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Stack;
+
 public class Traversal {
   public static void main(String[] args) {
     TreeNode<Integer> root = new TreeNode <Integer> (10, null, null);
@@ -13,22 +19,113 @@ public static void main(String[] args) {
 
     TreeNode <String> stringRoot = new TreeNode<String> ("Hello", null, null);
     stringRoot.left = new TreeNode <String> ("how", null,null);
-    stringRoot.left.left = new TreeNode<String> ("are", null,null);
+    stringRoot.left.left = new TreeNode<String> ("Hello", null,null);
     stringRoot.left.right = new TreeNode <String> ("you", null,null);
 
     stringRoot.right = new TreeNode <String> ("I", null, null);
     stringRoot.right.left = new TreeNode <String> ("am", null, null);
-    stringRoot.right.right = new TreeNode <String> ("so", null, null);
+    stringRoot.right.right = new TreeNode <String> ("am", null, null);
     stringRoot.right.right.right = new TreeNode <String> ("good", null, null);
 
+    TreeNode<Integer> megaRoot = new TreeNode<Integer>(1, null, null);
+
+    TreeNode<Integer> current = megaRoot;
+
+    for(int i =2; i <= 5000; i++){
+      current.right = new TreeNode<Integer>(i, null, null);
+      current = current.right;
+    }
+
+    levelOrder(root);
+    //preOrderIter(megaRoot);
+
+    // System.out.println("Preorder recursive");
+    // preorder(root);
+    // System.out.println("Preorder Iterativr");
+    // preOrderIter(root);
 
     //preorder(root);
     //postorder(root);
     //inorder(root);
 
     //printGreater(root, 4);
-    System.out.println(countNodes(root));
+    //System.out.println(countNodes(root));
+    
+    //System.out.println(toMap(stringRoot));
+
+  }
+
+    // Print a tree rooted at the given node in pre-order
+  public static void preorder(TreeNode<?> node){
+    //if null, return
+    if(node == null) return;
+    //print value
+    System.out.println(node.value);
+    //traverse left to recursion and tree works
+    preorder(node.left);
+    //traverse right
+    preorder(node.right);
 
+  }
+
+  public static <T> void preOrderIter(TreeNode<T> node){
+    Stack<TreeNode<T>> stack = new Stack<>();
+
+    stack.push(node);
+
+    while(!stack.empty()){
+      TreeNode<T> current = stack.pop();
+
+      if(current == null){
+        continue;
+      }
+        System.out.println(current.value);
+        stack.push(current.right);
+        stack.push(current.left);
+     
+      
+      
+    }
+  }
+
+   public static <T> void levelOrder(TreeNode<T> node){
+    Queue<TreeNode<T>> queue = new LinkedList<>();
+
+    queue.add(node);
+
+    while(!queue.isEmpty()){
+      TreeNode<T> current = queue.poll();
+
+      if(current == null){
+        continue;
+      }
+        System.out.println(current.value);
+        queue.add(current.left);
+        queue.add(current.right);
+  
+      
+    }
+  }
+
+
+  public static <T> Map<T, Integer> toMap(TreeNode<T> node) {
+    Map<T, Integer> counts = new HashMap<>();
+    toMap(node, counts);
+    return counts;
+
+  }
+  //overloading and helper method
+
+  private static <T> void  toMap(TreeNode<T> node, Map<T, Integer> counts ) {
+    
+    if(node == null) {
+      return;
+    }
+    //fill up those counts
+    counts.put(node.value, counts.getOrDefault(node.value, 0) +1);
+    toMap(node.left, counts);
+    toMap(node.right, counts);
+    
 
   }
 
@@ -53,18 +150,7 @@ public static void printGreater(TreeNode<Integer> node, int threshold) {
  }
 
 
-  // Print a tree rooted at the given node in pre-order
-  public static void preorder(TreeNode<?> node){
-    //if null, return
-    if(node == null) return;
-    //print value
-    System.out.println(node.value);
-    //traverse left to recursion and tree works
-    preorder(node.left);
-    //traverse right
-    preorder(node.right);
 
-  }
 
   public static <T> void postorder(TreeNode<T> node){
     if(node == null) return;