From 8eca23231d551b0e83a4d4facd8a4fce006c2f3d Mon Sep 17 00:00:00 2001
From: Elvin Hrytsyuk <183242754+Elvin-code-dev@users.noreply.github.com>
Date: Thu, 12 Feb 2026 14:48:14 -0800
Subject: [PATCH 1/4]  all done

---
 src/Traversal.java | 49 ++++++++++++++++++++++++++++++++++++++++++++++
 src/TreeNode.java  | 11 ++++++++++-
 2 files changed, 59 insertions(+), 1 deletion(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index 8da0f79..35355ae 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,5 +1,54 @@
 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 tree rooted at the given node in preorder
+  public static void preorder(TreeNode node) {
+    if(node == null){
+      return;
+    }
+    System.out.println(node.value);
+    preorder(node.left);
+    preorder(node.right);
+
+  }
+
+  public static void postorder(TreeNode node){
+    if(node == null){
+      return;
+    }
+
+    postorder(node.left);
+    postorder(node.right);
+
+    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..ee831f7 100644
--- a/src/TreeNode.java
+++ b/src/TreeNode.java
@@ -1,4 +1,13 @@
 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 3c1fdbea3846da834d8b7c1e8edfb909ceccedec Mon Sep 17 00:00:00 2001
From: Elvin Hrytsyuk <183242754+Elvin-code-dev@users.noreply.github.com>
Date: Tue, 17 Feb 2026 14:36:17 -0800
Subject: [PATCH 2/4] day 2 done

---
 src/Traversal.java | 59 ++++++++++++++++++++++++++++++++++++----------
 src/TreeNode.java  | 12 +++++-----
 2 files changed, 52 insertions(+), 19 deletions(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index 35355ae..cb95a2d 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,22 +1,55 @@
 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>("great", null, null);
+    stringRoot.right.left = new TreeNode<String>( "awesome", null,null);
+    stringRoot.right.right = new TreeNode<String>( "nice", null,null);
+    stringRoot.right.right.right = new TreeNode<String>("cool", null, null);
 
     //preorder(root);
     //postorder(root);
-    inorder(root);
+    //inorder(root);
+    //inorder(stringRoot);
+    //printGreater(root, 100);
+
+    System.out.println(countNodes(root));
+  }
+
+  public static int  countNodes(TreeNode<?> node){
+    return node == null ? 0 : 1 + countNodes(node.left) + countNodes(node.right);
+    //if(node == null) return 0;
+    //return 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 tree rooted at the given node in preorder
-  public static void preorder(TreeNode node) {
+  public static void preorder(TreeNode<?> node) {
     if(node == null){
       return;
     }
@@ -26,7 +59,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;
     }
@@ -35,9 +68,9 @@ public static void postorder(TreeNode node){
     postorder(node.right);
 
     System.out.println(node.value);
-  }
+    }
 
-  public static void inorder(TreeNode node) {
+  public static <E> void inorder(TreeNode<E> node) {
     if(node == null){
       return;
     }
diff --git a/src/TreeNode.java b/src/TreeNode.java
index ee831f7..928f711 100644
--- a/src/TreeNode.java
+++ b/src/TreeNode.java
@@ -1,11 +1,11 @@
-public class TreeNode {
+public class TreeNode<T> {
 
-  public int value;
-  public TreeNode left;
-  public TreeNode right;
+  public T value;
+  public TreeNode<T> left;
+  public TreeNode<T> right;
 
-  public TreeNode(int value, TreeNode left, TreeNode right){
-    this.value = value;
+  public TreeNode(T data, TreeNode<T> left, TreeNode<T> right){
+    this.value = data;
     this.left = left;
     this.right = right;
     

From a0f659ea1e299a212d339de19af86677b84ebe9c Mon Sep 17 00:00:00 2001
From: Elvin Hrytsyuk <183242754+Elvin-code-dev@users.noreply.github.com>
Date: Thu, 19 Feb 2026 14:30:39 -0800
Subject: [PATCH 3/4] Done #3

---
 src/Traversal.java | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index cb95a2d..c27ac04 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,3 +1,6 @@
+import java.util.HashMap;
+import java.util.Map;
+
 public class Traversal {
   public static void main(String[] args) {
     TreeNode<Integer> root = new TreeNode<Integer>( 10, null, null);
@@ -12,12 +15,12 @@ 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>("great", null, null);
     stringRoot.right.left = new TreeNode<String>( "awesome", null,null);
-    stringRoot.right.right = new TreeNode<String>( "nice", null,null);
+    stringRoot.right.right = new TreeNode<String>( "how", null,null);
     stringRoot.right.right.right = new TreeNode<String>("cool", null, null);
 
     //preorder(root);
@@ -26,7 +29,23 @@ public static void main(String[] args) {
     //inorder(stringRoot);
     //printGreater(root, 100);
 
-    System.out.println(countNodes(root));
+    //System.out.println(countNodes(root));
+    System.out.println(toMap(stringRoot));
+  }
+
+  public static <T> Map<T, Integer> toMap(TreeNode<T> node){
+    Map<T, Integer> counts = new HashMap<>();
+    toMap(node, counts);
+    return counts;
+  }
+
+  private static <T> void toMap(TreeNode<T> node, Map<T, Integer> counts){
+    if(node ==  null){
+      return;
+    }
+    counts.put(node.value, counts.getOrDefault(node.value, 0) + 1);
+    toMap(node.left, counts);
+    toMap(node.right, counts);
   }
 
   public static int  countNodes(TreeNode<?> node){

From b599cd8c6c70797d6ac77ddfb3fec6268a864b21 Mon Sep 17 00:00:00 2001
From: Elvin Hrytsyuk <183242754+Elvin-code-dev@users.noreply.github.com>
Date: Tue, 24 Feb 2026 14:50:53 -0800
Subject: [PATCH 4/4] all done

---
 src/Traversal.java | 84 ++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 73 insertions(+), 11 deletions(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index c27ac04..cce5af9 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,5 +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) {
@@ -23,14 +27,81 @@ public static void main(String[] args) {
     stringRoot.right.right = new TreeNode<String>( "how", null,null);
     stringRoot.right.right.right = new TreeNode<String>("cool", null, null);
 
+
+    TreeNode<Integer> megaRoot = new TreeNode<Integer>(1, null, null);
+
+    TreeNode<Integer> current = megaRoot;
+    
+    for(int i = 2; i <= 50000; i++){
+      current.right = new TreeNode<Integer>(i,null,null);
+      current = current.right;
+    }
+
+    preOrderIter(megaRoot);
+
     //preorder(root);
+
+    // System.out.println("Preorder recursive");
+    // preorder(root);
+    // System.out.println("Preorder Itertive");
+    // preOrderIter(root);
+
     //postorder(root);
     //inorder(root);
     //inorder(stringRoot);
     //printGreater(root, 100);
 
     //System.out.println(countNodes(root));
-    System.out.println(toMap(stringRoot));
+    //System.out.println(toMap(stringRoot));
+    
+  }
+  //print tree rooted at the given node in preorder
+  public static void preorder(TreeNode<?> node) {
+    if(node == null){
+      return;
+    }
+    System.out.println(node.value);
+    preorder(node.left);
+    preorder(node.right);
+
+  }
+
+  
+  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.right);
+        queue.add(current.left);
+      
+    }
+  }
+  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> Map<T, Integer> toMap(TreeNode<T> node){
@@ -67,16 +138,7 @@ public static void printGreater(TreeNode<Integer> node, int threshold){
     printGreater(node.right, threshold);
   }
 
-  //print tree rooted at the given node in preorder
-  public static void preorder(TreeNode<?> node) {
-    if(node == null){
-      return;
-    }
-    System.out.println(node.value);
-    preorder(node.left);
-    preorder(node.right);
-
-  }
+  
 
   public static <T> void postorder(TreeNode<T> node){
     if(node == null){