From 00956dfe582dff567b9ab34841c7a61c571a0ba6 Mon Sep 17 00:00:00 2001
From: Lilian <210286008+liliann19@users.noreply.github.com>
Date: Thu, 12 Feb 2026 14:49:20 -0800
Subject: [PATCH 1/4] tree-implement live code in class

---
 src/Traversal.java | 38 +++++++++++++++++++++++++++++++++++++-
 src/TreeNode.java  |  9 ++++++++-
 2 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index 8da0f79..56e51ac 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,5 +1,41 @@
 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; // if null, return
+    System.out.println(node.value); // print value 
+    preorder(node.left); // traverse left
+    preorder(node.right); // traverse right 
+  }
+
+  // Print a tree rooted at the given node in post-order
+  public static void postorder(TreeNode node) {
+    if (node == null) return;
+    postorder(node.left);
+    postorder(node.right);
+    System.out.println(node.value);
+  }
+
+  // Print a tree rooted at the given node in in-order
+  public static void inorder(TreeNode node) {
+    if (node == null) return;
+    inorder(node.left);
+    System.out.println(node.value);
+    inorder(node.right);
   }
-}
+}
\ No newline at end of file
diff --git a/src/TreeNode.java b/src/TreeNode.java
index acd9639..4b01796 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 8c2483b5405b18f6899fd0d5ee1ffd8e86bae063 Mon Sep 17 00:00:00 2001
From: Lilian <210286008+liliann19@users.noreply.github.com>
Date: Tue, 17 Feb 2026 14:37:02 -0800
Subject: [PATCH 2/4] made TreeNode generic and implemented countNodes method

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

diff --git a/src/Traversal.java b/src/Traversal.java
index 56e51ac..5079f73 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,22 +1,57 @@
 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<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);
 
-    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);
+    //inorder(stringRoot);
+
+    //printGreater(root, 4);
+    System.out.println(countNodes(root));
+  }
+
+  public static int countNodes(TreeNode<?> node) {
+    if (node == null) return 0;
+    return countNodes(node.left) + countNodes(node.right) + 1;
+
+    //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 (node == null) return; // if null, return
     System.out.println(node.value); // print value 
     preorder(node.left); // traverse left
@@ -24,7 +59,7 @@ public static void preorder(TreeNode node) {
   }
 
   // Print a tree rooted at the given node in post-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);
@@ -32,7 +67,7 @@ public static void postorder(TreeNode node) {
   }
 
   // Print a tree rooted at the given node in in-order
-  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 4b01796..71bb3ca 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 8baa83c3cecb572a3414993f308195543273a39d Mon Sep 17 00:00:00 2001
From: Lilian <210286008+liliann19@users.noreply.github.com>
Date: Thu, 19 Feb 2026 14:30:44 -0800
Subject: [PATCH 3/4] in class live code

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

diff --git a/src/Traversal.java b/src/Traversal.java
index 5079f73..20e40f0 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);
@@ -13,11 +16,11 @@ 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.right = new TreeNode<String>("you", null, null);
+    stringRoot.left.right = new TreeNode<String>("hello", 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);
 
 
@@ -26,7 +29,24 @@ public static void main(String[] args) {
     //inorder(stringRoot);
 
     //printGreater(root, 4);
-    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;
+    
+    // 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) {

From e7b3d78918937d7d110f5d7e407b101555e918e1 Mon Sep 17 00:00:00 2001
From: Lilian <210286008+liliann19@users.noreply.github.com>
Date: Tue, 24 Feb 2026 14:51:44 -0800
Subject: [PATCH 4/4] live code day 4

---
 src/Traversal.java | 130 ++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 111 insertions(+), 19 deletions(-)

diff --git a/src/Traversal.java b/src/Traversal.java
index 20e40f0..f922ed4 100644
--- a/src/Traversal.java
+++ b/src/Traversal.java
@@ -1,5 +1,9 @@
 import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.List;
 import java.util.Map;
+import java.util.Stack;
 
 public class Traversal {
   public static void main(String[] args) {
@@ -23,6 +27,33 @@ 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;
+    }
+
+    levelOrder(root);
+
+    //preOrderIter(megaRoot);
+
+    // System.out.println("Preorder recursive");
+    // preorder(root);
+    // System.out.println("Preorder iterative");
+    // preOrderIter(root);
+
+    TreeNode<Integer> newRoot = new TreeNode<Integer>(3, new TreeNode<Integer>(9, null, new TreeNode<Integer>(4, null, null)), null);
+    //newRoot.left = new TreeNode<Integer>(9, null, null);
+    //newRoot.left.right = new TreeNode<Integer>(4, null, null);
+    newRoot.right = new TreeNode<Integer>(4, null, null);
+    newRoot.right.left = new TreeNode<Integer>(9, null, null);
+    newRoot.right.right = new TreeNode<Integer>(6, null, null);
+    newRoot.right.right.left = new TreeNode<Integer>(4, null, null);
+
+    // { "hello": 1, "how": 2, "you": 1 }
+    List<String> wordList = List.of("hello", "how", "you", "how");
+    //System.out.println(listToMap(wordList));
 
     //preorder(root);
     //postorder(root);
@@ -31,24 +62,93 @@ public static void main(String[] args) {
     //printGreater(root, 4);
     //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; // if null, return
+    System.out.println(node.value); // print value 
+    preorder(node.left); // traverse left
+    preorder(node.right); // traverse right 
+  }
+
+  // depth first search 
+  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) {
-    Map<T, Integer> counts = new HashMap<>();
-    toMap(node, counts);
-    return counts;
+  // breath first search (level order)
+  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);
+    }
   }
 
-  private static <T> void toMap(TreeNode<T> node, Map<T, Integer> counts) {
-    if(node == null) return;
+  // 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);
+  //   // fill up those counts
+  //   counts.put(node.value, counts.getOrDefault(node.value, 0) + 1);
+  //   toMap(node.left, counts);
+  //   toMap(node.right, counts);
+  // }
+
+  public static Map<String, Integer> listToMap(List<String> list){
+
+//     for word in list:
+//        if our word is a key in the map:
+// 	        newValue = map.get(word) + 1
+// 	        map.put(word, newValue)
+//        else:
+// 	        map.put(word, 1)
+
+    // "hello", "how", "you", "how"
+
+    Map<String, Integer> map = new HashMap<>(); // {"hello": 1, "how": 1, "you": 1}
+
+    int count = 0;
+
+    for (int i = 0; i < list.size(); i++) {
+      String word = list.get(i); // how 
+
+      if (map.containsKey(word)){
+        count = map.get(word) + 1; // value of count = 2
+        map.put(word, count);
+      } else {
+        map.put(word, 1);
+      }
+    }
+    return map;
   }
 
+
   public static int countNodes(TreeNode<?> node) {
     if (node == null) return 0;
     return countNodes(node.left) + countNodes(node.right) + 1;
@@ -70,14 +170,6 @@ 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; // if null, return
-    System.out.println(node.value); // print value 
-    preorder(node.left); // traverse left
-    preorder(node.right); // traverse right 
-  }
-
   // Print a tree rooted at the given node in post-order
   public static <T> void postorder(TreeNode<T> node) {
     if (node == null) return;