youngyangyang04 · zsong96wisc · Aug 27, 2025
diff --git a/problems/100_Same_Tree/solution_1.txt b/problems/100_Same_Tree/solution_1.txt
@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        if (p == q && q == null) return true;
+
+        if ((p==null && q!=null) || (q==null && p!=null)) return false;
+
+        if (p.val != q.val) return false;
+
+        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+    }
+}
diff --git a/problems/101_Symmetric_Tree/solution_1.txt b/problems/101_Symmetric_Tree/solution_1.txt
@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean isSymmetric(TreeNode root) {
+        return checkSymmetric(root, root);
+    }
+
+    private boolean checkSymmetric(TreeNode root1, TreeNode root2){
+        if (root1 == null && root2 == null) {
+            return true;
+        } else if (root1 == null || root2 == null){
+            return false;
+        }
+        return (root1.val == root2.val) && checkSymmetric(root1.left, root2.right) && checkSymmetric(root1.right, root2.left);
+    }
+}
diff --git a/problems/104_Maximum_Depth_of_Binary_Tree/solution_1.txt b/problems/104_Maximum_Depth_of_Binary_Tree/solution_1.txt
@@ -0,0 +1,22 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int maxDepth(TreeNode root) {
+        if (root == null) return 0;
+
+        return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
+    }
+}
diff --git a/problems/108_Convert_Sorted_Array_to_Binary_Search_Tree/solution_1.txt b/problems/108_Convert_Sorted_Array_to_Binary_Search_Tree/solution_1.txt
@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode sortedArrayToBST(int[] nums) {
+        return split(0, nums.length - 1, nums);
+    }
+
+    private TreeNode split(int left, int right, int[] nums){
+        if (right - left == 0){
+            return new TreeNode(nums[left]);
+        }
+
+        if (right - left == 1){
+            return new TreeNode(nums[left], null, new TreeNode(nums[right]));
+        }
+
+        int mid = left + (right - left) / 2;
+        TreeNode root = new TreeNode(nums[mid]);
+        root.left = split(left, mid - 1, nums);
+        root.right = split(mid + 1, right, nums);
+
+        return root;
+    }
+}
diff --git a/problems/112_Path_Sum/solution_1.txt b/problems/112_Path_Sum/solution_1.txt
@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean hasPathSum(TreeNode root, int targetSum) {
+        return Sum(root, targetSum);
+    }
+
+    public boolean Sum(TreeNode node, int targetSum) {
+        if (node == null) return false;
+        if (node.left == null && node.right == null 
+            && targetSum == node.val) return true; 
+
+        return Sum(node.left, targetSum - node.val) 
+            || Sum (node.right, targetSum - node.val);
+    }
+}
diff --git a/problems/113_Path_Sum_II/solution_1.txt b/problems/113_Path_Sum_II/solution_1.txt
@@ -0,0 +1,39 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
+        List<List<Integer>> result = new ArrayList<>();
+        Sum(root, targetSum, result, new ArrayList<Integer>());
+        return result;
+    }
+
+    private void Sum(TreeNode node, int targetSum, List<List<Integer>> result, ArrayList<Integer> lists){
+        if (node == null) return;
+        if (node.left == null && node.right == null && targetSum == node.val) {
+            lists.add(node.val);
+            result.add(new ArrayList<Integer>(lists));
+            lists.remove(lists.size() - 1);
+            return;
+        } 
+
+        lists.add(node.val);
+
+        Sum(node.left, targetSum - node.val, result, lists);
+        Sum(node.right, targetSum - node.val, result, lists);
+
+        lists.remove(lists.size() - 1);
+    }
+}
diff --git a/problems/11_Container With Most Water/solution_1.txt b/problems/11_Container With Most Water/solution_1.txt
@@ -0,0 +1,18 @@
+class Solution {
+    public int maxArea(int[] height) {
+        int start = 0;
+        int end = height.length - 1;
+        int max = 0;
+
+        while (start < end){
+            max = Math.max((end - start) * Math.min(height[start], height[end]), max);
+
+            if (height[start] > height[end]) {
+                end--;
+            } else {
+                start++;
+            }
+        }
+        return max;
+    }
+}
diff --git a/problems/147_Insertion_Sort_List/solution_1.txt b/problems/147_Insertion_Sort_List/solution_1.txt
@@ -0,0 +1,47 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode insertionSortList(ListNode head) {
+       if (head == null || head.next == null) return head;
+
+       ListNode current = head;
+
+       while (current != null && current.next != null){
+           if (current.val > current.next.val){
+               ListNode value = current.next;
+               current.next = current.next.next;
+
+               if (head.val >= value.val){
+                   value.next = head;
+                   head = value;
+                   continue;
+               } 
+
+               ListNode m = head;
+
+               while (m.next != null){
+                   if (m.next.val > value.val){
+                       value.next = m.next;
+                       m.next = value;
+                       break;
+                   }
+                   m = m.next;
+               }
+           } else {
+               current = current.next;
+           }
+
+       }
+
+
+       return head; 
+    }
+}
diff --git a/problems/148_Sort_List/solution_1.txt b/problems/148_Sort_List/solution_1.txt
@@ -0,0 +1,60 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode sortList(ListNode head) {
+        if (head == null || head.next == null) return head;
+        ListNode mid = findMid(head);
+        ListNode left = sortList(head);
+        ListNode right = sortList(mid);
+        return MergeList(left, right);
+    }
+
+    private ListNode MergeList (ListNode L1, ListNode L2){
+        ListNode dummyNode = new ListNode();
+        ListNode tail = dummyNode;
+
+        while (L1 != null && L2 != null){
+            if (L1.val <= L2.val){
+                tail.next = L1;
+                L1 = L1.next;
+                tail = tail.next;
+            } else {
+                tail.next = L2;
+                L2 = L2.next;
+                tail = tail.next;
+            }
+        }
+
+        if (L1 == null) {
+            tail.next = L2;
+        } else {
+            tail.next = L1;
+        }
+        return dummyNode.next;
+    }
+
+    private ListNode findMid(ListNode head){
+        ListNode slow = null;
+
+        while (head != null && head.next != null){
+            if (slow == null){
+                slow = head;
+            } else {
+                slow = slow.next;
+            }
+            head = head.next.next;
+        }
+
+        ListNode mid = slow.next;
+        slow.next = null;
+        return mid;
+    }
+}
diff --git a/problems/15_3sum/solution_1.txt b/problems/15_3sum/solution_1.txt
@@ -0,0 +1,32 @@
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums);
+        List<List<Integer>> result = new ArrayList<>();
+        int start = 0;
+        int end = 0;
+
+        for (int i = 0; i < nums.length-2; i++){
+            if (i > 0 && nums[i] == nums[i-1])
+                continue;
+            int j = i + 1;
+            int k = nums.length-1;
+            while(j < k){
+                if (nums[j] + nums[k] > -nums[i])
+                    k--;
+                else if (nums[j] + nums[k] < -nums[i])
+                    j++;
+                else {        
+                    ArrayList<Integer> numbers = new ArrayList<>();
+                    numbers.add(nums[i]);
+                    numbers.add(nums[j]);
+                    numbers.add(nums[k]);
+                    result.add(numbers);
+                    j++;
+                    while (nums[j] == nums[j-1] && j < k)
+                        j++;
+                }
+            }
+        }
+        return result;
+    }
+}
diff --git a/problems/16_3sum_Closest/solution_1.txt b/problems/16_3sum_Closest/solution_1.txt
@@ -0,0 +1,25 @@
+class Solution {
+    public int threeSumClosest(int[] nums, int target) {
+        Arrays.sort(nums);
+
+        int diff = Integer.MAX_VALUE;
+
+        for (int i = 0; i < nums.length - 2; i++){
+            int j = i + 1;
+            int k = nums.length - 1;
+            while (j < k){
+                if (Math.abs(nums[i] + nums[j] + nums[k] - target) < Math.abs(diff)){
+                    diff = nums[i] + nums[j] + nums[k] - target;
+                }
+                if (nums[i] + nums[j] + nums[k] > target){
+                    k--;
+                } else if (nums[i] + nums[j] + nums[k] < target){
+                    j++;
+                } else {
+                    return nums[i] + nums[j] + nums[k];
+                }
+            }
+        }
+        return diff + target;
+    }
+}