From 4448a3d40a1d145627fd5c6941ce81c8c11dd1bf Mon Sep 17 00:00:00 2001
From: SouthBennett <146032836+SouthBennett@users.noreply.github.com>
Date: Thu, 12 Feb 2026 14:49:35 -0800
Subject: [PATCH 1/4] Tree Implement Livecode Day 1

---
 src/Traversal.java | 35 +++++++++++++++++++++++++++++++++++
 src/TreeNode.java  |  9 ++++++++-
 2 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index 8da0f79..b649b59 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,5 +1,40 @@
 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 (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..e0e5a9e 100644
--- a/src/TreeNode.java
+++ b/src/TreeNode.java
@@ -1,4 +1,11 @@
 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 078d24225b54d2b14a61fad8420f31413f5b13d6 Mon Sep 17 00:00:00 2001
From: SouthBennett <146032836+SouthBennett@users.noreply.github.com>
Date: Tue, 17 Feb 2026 14:37:06 -0800
Subject: [PATCH 2/4] Tree Implement Livecode Day 2

---
 src/Traversal.java | 56 +++++++++++++++++++++++++++++++++++-----------
 src/TreeNode.java  | 10 ++++-----
 2 files changed, 48 insertions(+), 18 deletions(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index b649b59..7b35d3b 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,40 +1,70 @@
 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(stringRoot);
+
+    System.out.println(countNodes(root));
+  }
+
+  public static int countNodes(TreeNode<?> node) {
+    return node == null ? 0 : countNodes(node.left) + countNodes(node.right) + 1;
+    // 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 the given node in pre-order
-  public static void preOrder(TreeNode node) {
+  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) {
+  public static <T> void postOrder(TreeNode<T> node) {
     if (node == null) return;
     postOrder(node.left);
     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;
     inOrder(node.left);
     System.out.println(node.value);
     inOrder(node.right);
-  }
+  } 
 }
diff --git a/src/TreeNode.java b/src/TreeNode.java
index e0e5a9e..7044e0e 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 d87a5e28c9f9734418d95651c1e1b7eee1315c9f Mon Sep 17 00:00:00 2001
From: SouthBennett <146032836+SouthBennett@users.noreply.github.com>
Date: Thu, 19 Feb 2026 14:31:16 -0800
Subject: [PATCH 3/4] Tree Implement Livecode Day 3

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

diff --git a/src/Traversal.java b/src/Traversal.java
index 7b35d3b..679a2f7 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>("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);
 
 
@@ -25,12 +28,30 @@ public static void main(String[] args) {
     //postOrder(root);
     //inOrder(stringRoot);
 
-    System.out.println(countNodes(root));
+    // printGreater(root, 100);
+    // 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;
+    }  
+    // 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 : countNodes(node.left) + countNodes(node.right) + 1;
-    // if (node == null) return 0;
     // int leftCount = countNodes(node.left);
     // int rightCount = countNodes(node.right);
     // int overallCount = leftCount + rightCount + 1;

From 3b4c4e7bc5fef5272fa53422d64912a17ba88934 Mon Sep 17 00:00:00 2001
From: SouthBennett <146032836+SouthBennett@users.noreply.github.com>
Date: Tue, 24 Feb 2026 14:48:55 -0800
Subject: [PATCH 4/4] Tree Implement Livecode Day 4

---
 src/Traversal.java | 75 +++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 65 insertions(+), 10 deletions(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index 679a2f7..c67caa5 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) {
@@ -23,6 +26,24 @@ public static void main(String[] args) {
     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 <= 50000; i++) {
+      current.right = new TreeNode<Integer>(i, null, null);
+      current = current.right;
+    }
+
+
+
+    levelOrderIter(root);
+    //preOrderIter(megaRoot);
+
+    // System.out.println("Pre-order recursive");
+    // preOrder(root);
+    // System.out.println("Pre-order Iterative");
+    // preOrderIter(root);
 
     //preOrder(root);
     //postOrder(root);
@@ -31,7 +52,46 @@ public static void main(String[] args) {
     // printGreater(root, 100);
     // System.out.println(countNodes(root));
     
-    System.out.println(toMap(stringRoot));
+    // System.out.println(toMap(stringRoot));
+  }
+
+  // Print a tree rooted at the given node in pre-order
+  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 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);
+    }
+  }
+
+  // levelbylevel
+  public static <T> void levelOrderIter(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) {
@@ -67,14 +127,7 @@ public static void printGreater(TreeNode<Integer> node, int threshold) {
     printGreater(node.right, threshold);
   }
 
-  // Print a tree rooted at the given node in pre-order
-  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) return;
     postOrder(node.left);
@@ -87,5 +140,7 @@ public static <E> void inOrder(TreeNode<E> node) {
     inOrder(node.left);
     System.out.println(node.value);
     inOrder(node.right);
-  } 
+  }
+
+
 }