From d0d412162d9af255a8570292ae25c425694e57d2 Mon Sep 17 00:00:00 2001
From: Akaioka <brendanvillaraza@yahoo.com>
Date: Thu, 12 Feb 2026 14:49:25 -0800
Subject: [PATCH 1/4] Completed todays live code

---
 src/Traversal.java | 43 +++++++++++++++++++++++++++++++++++++++++++
 src/TreeNode.java  |  8 ++++++++
 2 files changed, 51 insertions(+)

diff --git a/src/Traversal.java b/src/Traversal.java
index 8da0f79..5ee293b 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,5 +1,48 @@
 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);
+
+    System.out.println();
+
+    System.out.print("pre-order: ");
+    preOrder(root);
+    System.out.println();
+    System.out.print("post-order: ");
+    postOrder(root);
+    System.out.println();
+    System.out.print("in-order: ");
+    inOrder(root);
+  }
+  
+  //Print a tree rooted at a given node in pre-order
+  public static void preOrder(TreeNode node){
+    if (node == null) return; 
+    System.out.print(node.value + " ");
+    preOrder(node.left);
+    preOrder(node.right);
+  }
+
+  //Print a tree rooted at a given node in pre-order
+  public static void postOrder(TreeNode node){
+    if (node == null) return; 
+    postOrder(node.left);
+    postOrder(node.right);
+    System.out.print(node.value + " ");
+  }
+
+  //Print a tree rooted at a given node in pre-order
+  public static void inOrder(TreeNode node){
+    if (node == null) return; 
+    postOrder(node.left);
+    System.out.print(node.value + " ");
+    postOrder(node.right);
   }
 }
diff --git a/src/TreeNode.java b/src/TreeNode.java
index acd9639..0f996f8 100644
--- a/src/TreeNode.java
+++ b/src/TreeNode.java
@@ -1,4 +1,12 @@
 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 0e8d6a9ec99a5ed18ee99e4cb2b0875a3fd9a43f Mon Sep 17 00:00:00 2001
From: Akai <161771111+Akaiokaa@users.noreply.github.com>
Date: Tue, 17 Feb 2026 17:35:50 -0800
Subject: [PATCH 2/4] Completed day 2 live code

---
 src/Traversal.java | 66 ++++++++++++++++++++++++++++++++--------------
 src/TreeNode.java  | 10 +++----
 2 files changed, 51 insertions(+), 25 deletions(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index 5ee293b..16ffafb 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,29 +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);
 
-    System.out.println();
+    TreeNode<String> stringRoot = new TreeNode<String>("Hello", null, null);
+    stringRoot.left = new TreeNode<String>("bine", null, null);
+    stringRoot.left.left = new TreeNode<String>("time", null, null);
+    stringRoot.left.right = new TreeNode<String>("lime", null, null);
 
-    System.out.print("pre-order: ");
-    preOrder(root);
-    System.out.println();
-    System.out.print("post-order: ");
-    postOrder(root);
+    stringRoot.right = new TreeNode<String>("chime", null, null);
+    stringRoot.right.left = new TreeNode<String>("bind", null, null);
+    stringRoot.right.right = new TreeNode<String>("climb", null, null);
+    stringRoot.right.right.right = new TreeNode<String>("help", null, null);
     System.out.println();
-    System.out.print("in-order: ");
-    inOrder(root);
+
+    // System.out.print("pre-order: ");
+    // preOrder(root);
+    // System.out.println();
+    // System.out.print("post-order: ");
+    // postOrder(root);
+    // System.out.println();
+    // System.out.print("in-order: ");
+    // inOrder(root);
+
+    // inOrder(stringRoot);
+    // printGreater(root, 4);
+    System.out.println(countNodes(stringRoot));
+  }
+  public static int countNodes(TreeNode<?> node){
+    return node == null ? 0 : 1 + countNodes(node.left) + countNodes(node.right);
+    // if (node == null) { return 0; }
+    // 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 a given node in pre-order
-  public static void preOrder(TreeNode node){
+  public static void preOrder(TreeNode<?> node){
     if (node == null) return; 
     System.out.print(node.value + " ");
     preOrder(node.left);
@@ -31,7 +57,7 @@ public static void preOrder(TreeNode node){
   }
 
   //Print a tree rooted at a given node in pre-order
-  public static void postOrder(TreeNode node){
+  public static <T> void postOrder(TreeNode<T> node){
     if (node == null) return; 
     postOrder(node.left);
     postOrder(node.right);
@@ -39,7 +65,7 @@ public static void postOrder(TreeNode node){
   }
 
   //Print a tree rooted at a given node in pre-order
-  public static void inOrder(TreeNode node){
+  public static <E> void inOrder(TreeNode<E> node){
     if (node == null) return; 
     postOrder(node.left);
     System.out.print(node.value + " ");
diff --git a/src/TreeNode.java b/src/TreeNode.java
index 0f996f8..19d9315 100644
--- a/src/TreeNode.java
+++ b/src/TreeNode.java
@@ -1,9 +1,9 @@
-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 460289b1981ea8d1fca112b57b401eda03c56a42 Mon Sep 17 00:00:00 2001
From: Akaioka <brendanvillaraza@yahoo.com>
Date: Thu, 19 Feb 2026 14:30:51 -0800
Subject: [PATCH 3/4] Completed livecode

---
 src/Traversal.java | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index 16ffafb..85fb79f 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);
@@ -10,13 +13,13 @@ public static void main(String[] args) {
     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);
+    TreeNode<String> stringRoot = new TreeNode<String>("hello", null, null);
     stringRoot.left = new TreeNode<String>("bine", null, null);
-    stringRoot.left.left = new TreeNode<String>("time", null, null);
+    stringRoot.left.left = new TreeNode<String>("hello", null, null);
     stringRoot.left.right = new TreeNode<String>("lime", null, null);
 
     stringRoot.right = new TreeNode<String>("chime", null, null);
-    stringRoot.right.left = new TreeNode<String>("bind", null, null);
+    stringRoot.right.left = new TreeNode<String>("lime", null, null);
     stringRoot.right.right = new TreeNode<String>("climb", null, null);
     stringRoot.right.right.right = new TreeNode<String>("help", null, null);
     System.out.println();
@@ -32,8 +35,24 @@ public static void main(String[] args) {
 
     // inOrder(stringRoot);
     // printGreater(root, 4);
-    System.out.println(countNodes(stringRoot));
+    // System.out.println(countNodes(stringRoot));
+    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;}
+    // fill up those counts
+    counts.put(node.value, counts.getOrDefault(node.value, 0) + 1);
+    toMap(node.left, counts);
+    toMap(node.right, counts);
+  }
+
+  
   public static int countNodes(TreeNode<?> node){
     return node == null ? 0 : 1 + countNodes(node.left) + countNodes(node.right);
     // if (node == null) { return 0; }

From b4538725c5790447106f18d93f6c6f401d4714c8 Mon Sep 17 00:00:00 2001
From: Akaioka <brendanvillaraza@yahoo.com>
Date: Tue, 24 Feb 2026 14:51:03 -0800
Subject: [PATCH 4/4] Completed todays livecode

---
 src/Traversal.java | 77 +++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 69 insertions(+), 8 deletions(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index 85fb79f..933bcc8 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,5 +1,8 @@
 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) {
@@ -36,7 +39,71 @@ public static void main(String[] args) {
     // inOrder(stringRoot);
     // printGreater(root, 4);
     // System.out.println(countNodes(stringRoot));
-    System.out.println(toMap(stringRoot));
+
+    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;
+
+    }
+    // preOrder(megaRoot);
+    // System.out.println(toMap(stringRoot));
+    // System.out.println("Preorder recursive");
+    // preOrder(root);
+    // System.out.println("Preorder recursive");
+    // preOrderIter(megaRoot);
+    LevelOrder(root);
+  }
+
+   //Print a tree rooted at a given node in pre-order
+   public static void preOrder(TreeNode<?> node){
+    if (node == null) return; 
+    System.out.print(node.value + " ");
+    preOrder(node.left);
+    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<>();
@@ -67,13 +134,7 @@ public static void printGreater(TreeNode<Integer> node, int threshold){
     printGreater(node.left, threshold);
     printGreater(node.right, threshold);
   }
-  //Print a tree rooted at a given node in pre-order
-  public static void preOrder(TreeNode<?> node){
-    if (node == null) return; 
-    System.out.print(node.value + " ");
-    preOrder(node.left);
-    preOrder(node.right);
-  }
+ 
 
   //Print a tree rooted at a given node in pre-order
   public static <T> void postOrder(TreeNode<T> node){