Updated markdown files

Author: Zanger67/leetcode

markdowns/_100. Same Tree.md

@@ -0,0 +1,50 @@
+# 100. [Same Tree](<https://leetcode.com/problems/same-tree>)
+
+*All prompts are owned by LeetCode. To view the prompt, click the title link above.*
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 10, 2024*
+>
+> *Last updated : July 10, 2024*
+
+------
+
+> **Related Topics** : **[Tree](<by_topic/Tree.md>), [Depth-First Search](<by_topic/Depth-First Search.md>), [Breadth-First Search](<by_topic/Breadth-First Search.md>), [Binary Tree](<by_topic/Binary Tree.md>)**
+>
+> **Acceptance Rate** : **62.636 %**
+
+------
+
+## Solutions
+
+- [100.same-tree.py](<../my-submissions/100.same-tree.py>)
+### Python
+#### [100.same-tree.py](<../my-submissions/100.same-tree.py>)
+```Python
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
+
+        if not p and not q :
+            return True
+
+        if not p or not q :
+            return False
+        
+        if p.val != q.val :
+            return False
+        
+        return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
+        
+
+```
+

markdowns/_102. Binary Tree Level Order Traversal.md

@@ -0,0 +1,68 @@
+# 102. [Binary Tree Level Order Traversal](<https://leetcode.com/problems/binary-tree-level-order-traversal>)
+
+*All prompts are owned by LeetCode. To view the prompt, click the title link above.*
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 10, 2024*
+>
+> *Last updated : July 10, 2024*
+
+------
+
+> **Related Topics** : **[Tree](<by_topic/Tree.md>), [Breadth-First Search](<by_topic/Breadth-First Search.md>), [Binary Tree](<by_topic/Binary Tree.md>)**
+>
+> **Acceptance Rate** : **67.774 %**
+
+------
+
+## Solutions
+
+- [m102.java](<../my-submissions/m102.java>)
+### Java
+#### [m102.java](<../my-submissions/m102.java>)
+```Java
+/**
+ * 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>> levelOrder(TreeNode root) {
+        List<List<Integer>> output = new LinkedList<>();
+        helper(root, 0, output);
+        return output;
+    }
+
+    private void helper(TreeNode curr, int depth, List<List<Integer>> output) {
+        if (curr == null) {
+            return;
+        }
+        if (output.size() <= depth) {
+            output.add(new LinkedList<Integer>());
+        }
+        output.get(depth).add(curr.val);
+
+        depth++;
+        if (curr.left != null) {
+            helper(curr.left, depth, output);
+        }
+        if (curr.right != null) {
+            helper(curr.right, depth, output);
+        }
+    }
+}
+```
+

markdowns/_103. Binary Tree Zigzag Level Order Traversal.md

@@ -0,0 +1,83 @@
+# 103. [Binary Tree Zigzag Level Order Traversal](<https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal>)
+
+*All prompts are owned by LeetCode. To view the prompt, click the title link above.*
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 10, 2024*
+>
+> *Last updated : July 10, 2024*
+
+------
+
+> **Related Topics** : **[Tree](<by_topic/Tree.md>), [Breadth-First Search](<by_topic/Breadth-First Search.md>), [Binary Tree](<by_topic/Binary Tree.md>)**
+>
+> **Acceptance Rate** : **59.391 %**
+
+------
+
+## Solutions
+
+- [103.binary-tree-zigzag-level-order-traversal.py](<../my-submissions/103.binary-tree-zigzag-level-order-traversal.py>)
+- [m103.py](<../my-submissions/m103.py>)
+### Python
+#### [103.binary-tree-zigzag-level-order-traversal.py](<../my-submissions/103.binary-tree-zigzag-level-order-traversal.py>)
+```Python
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        
+
+```
+
+#### [m103.py](<../my-submissions/m103.py>)
+```Python
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if not root :
+            return []
+        toVisit = deque([root])
+        leftRight = True
+        output = []
+
+        while toVisit :
+            width = len(toVisit)
+            lvl = []
+            for i in range(width):
+                if leftRight :
+                    curr = toVisit.popleft()
+                    lvl.append(curr.val)
+                    if curr.left :
+                        toVisit.append(curr.left)
+                    if curr.right :
+                        toVisit.append(curr.right)
+                else :
+                    curr = toVisit.pop()
+                    lvl.append(curr.val)
+                    if curr.right :
+                        toVisit.appendleft(curr.right)
+                    if curr.left :
+                        toVisit.appendleft(curr.left)
+
+            output.append(lvl)
+            leftRight = not leftRight
+        return output
+        
+
+```
+

markdowns/_104. Maximum Depth of Binary Tree.md

@@ -0,0 +1,39 @@
+# 104. [Maximum Depth of Binary Tree](<https://leetcode.com/problems/maximum-depth-of-binary-tree>)
+
+*All prompts are owned by LeetCode. To view the prompt, click the title link above.*
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 10, 2024*
+>
+> *Last updated : July 10, 2024*
+
+------
+
+> **Related Topics** : **[Tree](<by_topic/Tree.md>), [Depth-First Search](<by_topic/Depth-First Search.md>), [Breadth-First Search](<by_topic/Breadth-First Search.md>), [Binary Tree](<by_topic/Binary Tree.md>)**
+>
+> **Acceptance Rate** : **75.683 %**
+
+------
+
+## Solutions
+
+- [e104.py](<../my-submissions/e104.py>)
+### Python
+#### [e104.py](<../my-submissions/e104.py>)
+```Python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root :
+            return 0
+        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))
+```
+

markdowns/_107. Binary Tree Level Order Traversal II.md

@@ -0,0 +1,75 @@
+# 107. [Binary Tree Level Order Traversal II](<https://leetcode.com/problems/binary-tree-level-order-traversal-ii>)
+
+*All prompts are owned by LeetCode. To view the prompt, click the title link above.*
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 10, 2024*
+>
+> *Last updated : July 10, 2024*
+
+------
+
+> **Related Topics** : **[Tree](<by_topic/Tree.md>), [Breadth-First Search](<by_topic/Breadth-First Search.md>), [Binary Tree](<by_topic/Binary Tree.md>)**
+>
+> **Acceptance Rate** : **63.801 %**
+
+------
+
+> This also could have easily been done by reversing the left-right 
+> traversal order, then just using the default `Collections` `reverse` 
+> function to have the deepest layers appear first.
+
+------
+
+## Solutions
+
+- [m107.java](<../my-submissions/m107.java>)
+### Java
+#### [m107.java](<../my-submissions/m107.java>)
+```Java
+/**
+ * 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>> levelOrderBottom(TreeNode root) {
+        HashMap<Integer, List<Integer>> levelOrderVals = new HashMap<>();
+        int maxDepth = helper(root, 0, levelOrderVals);
+
+        List<List<Integer>> output = new LinkedList<>();
+        for (int i = maxDepth; i >= 0; i--) {
+            output.add(levelOrderVals.get(i));
+        }
+
+        return output;
+    }
+
+    private int helper(TreeNode curr, int depth, HashMap<Integer, List<Integer>> levelOrderVals) {
+        if (curr == null) {
+            return depth - 1;
+        }
+        if (!levelOrderVals.containsKey(depth)) {
+            levelOrderVals.put(depth, new LinkedList<Integer>());
+        }
+        levelOrderVals.get(depth).add(curr.val);
+
+        depth++;
+        return Integer.max(helper(curr.left, depth, levelOrderVals), helper(curr.right, depth, levelOrderVals));
+    }
+}
+```
+

markdowns/_110. Balanced Binary Tree.md

@@ -0,0 +1,51 @@
+# 110. [Balanced Binary Tree](<https://leetcode.com/problems/balanced-binary-tree>)
+
+*All prompts are owned by LeetCode. To view the prompt, click the title link above.*
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 10, 2024*
+>
+> *Last updated : July 10, 2024*
+
+------
+
+> **Related Topics** : **[Tree](<by_topic/Tree.md>), [Depth-First Search](<by_topic/Depth-First Search.md>), [Binary Tree](<by_topic/Binary Tree.md>)**
+>
+> **Acceptance Rate** : **52.638 %**
+
+------
+
+## Solutions
+
+- [e110.py](<../my-submissions/e110.py>)
+### Python
+#### [e110.py](<../my-submissions/e110.py>)
+```Python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def isBalanced(self, root: Optional[TreeNode]) -> bool:
+        def dfs(curr: Optional[TreeNode]) -> int :
+            if not curr :
+                return 0
+            
+            left, right = dfs(curr.left), dfs(curr.right)
+
+            if left == -1 or right == -1 :
+                return -1
+
+            if abs(left - right) > 1 :
+                return -1
+
+            return max(left, right) + 1
+
+        return True if dfs(root) != -1 else False
+```
+