Neetcode 150 additional questions

Author: Zanger67

.Readme Updater

@@ -6,6 +6,12 @@ Calculations are based on the date of the first solve.
 
 |    # | Title                                                                                                                                                                                    | Level   | Cats           | Solution                                                                                           | Languages                        | Date Complete   |
 |-----:|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------|:---------------|:---------------------------------------------------------------------------------------------------|:---------------------------------|:----------------|
+|  124 | [Binary Tree Maximum Path Sum](<https://leetcode.com/problems/binary-tree-maximum-path-sum>)                                                                                             | Hard    | B75, N150      | [solution](<_124. Binary Tree Maximum Path Sum.md>)                                                | py                               | Jul 04, 2024    |
+| 1448 | [Count Good Nodes in Binary Tree](<https://leetcode.com/problems/count-good-nodes-in-binary-tree>)                                                                                       | Medium  | N150           | [solution](<_1448. Count Good Nodes in Binary Tree.md>)                                            | java                             | Jul 04, 2024    |
+|  199 | [Binary Tree Right Side View](<https://leetcode.com/problems/binary-tree-right-side-view>)                                                                                               | Medium  | N150           | [solution](<_199. Binary Tree Right Side View.md>)                                                 | java, cpp                        | Jul 04, 2024    |
+|  235 | [Lowest Common Ancestor of a Binary Search Tree](<https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree>)                                                         | Medium  | B75, N150      | [solution](<_235. Lowest Common Ancestor of a Binary Search Tree.md>)                              | py                               | Jul 04, 2024    |
+|  110 | [Balanced Binary Tree](<https://leetcode.com/problems/balanced-binary-tree>)                                                                                                             | Easy    | N150           | [solution](<_110. Balanced Binary Tree.md>)                                                        | py                               | Jul 04, 2024    |
+|  104 | [Maximum Depth of Binary Tree](<https://leetcode.com/problems/maximum-depth-of-binary-tree>)                                                                                             | Easy    | B75, N150      | [solution](<_104. Maximum Depth of Binary Tree.md>)                                                | py                               | Jul 04, 2024    |
 |   82 | [Remove Duplicates from Sorted List II](<https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii>)                                                                           | Medium  |                | [solution](<_82. Remove Duplicates from Sorted List II.md>)                                        | py                               | Jul 04, 2024    |
 | 1836 | [Remove Duplicates From an Unsorted Linked List](<https://leetcode.com/problems/remove-duplicates-from-an-unsorted-linked-list>)                                                         | Medium  |                | [solution](<_1836. Remove Duplicates From an Unsorted Linked List.md>)                             | py                               | Jul 04, 2024    |
 | 2046 | [Sort Linked List Already Sorted Using Absolute Values](<https://leetcode.com/problems/sort-linked-list-already-sorted-using-absolute-values>)                                           | Medium  |                | [solution](<_2046. Sort Linked List Already Sorted Using Absolute Values.md>)                      | py                               | Jul 04, 2024    |

README.md

@@ -7,13 +7,13 @@
 - [Array](<by_topic/Array.md>) (171 completed)
 - [Hash Table](<by_topic/Hash Table.md>) (83 completed)
 - [String](<by_topic/String.md>) (83 completed)
-- [Depth-First Search](<by_topic/Depth-First Search.md>) (59 completed)
-- [Tree](<by_topic/Tree.md>) (54 completed)
+- [Depth-First Search](<by_topic/Depth-First Search.md>) (65 completed)
+- [Tree](<by_topic/Tree.md>) (60 completed)
+- [Binary Tree](<by_topic/Binary Tree.md>) (55 completed)
 - [Sorting](<by_topic/Sorting.md>) (54 completed)
-- [Binary Tree](<by_topic/Binary Tree.md>) (49 completed)
 - [Math](<by_topic/Math.md>) (46 completed)
+- [Breadth-First Search](<by_topic/Breadth-First Search.md>) (43 completed)
 - [Two Pointers](<by_topic/Two Pointers.md>) (41 completed)
-- [Breadth-First Search](<by_topic/Breadth-First Search.md>) (40 completed)
 - [Linked List](<by_topic/Linked List.md>) (37 completed)
 - [Stack](<by_topic/Stack.md>) (34 completed)
 - [Greedy](<by_topic/Greedy.md>) (30 completed)
@@ -24,12 +24,12 @@
 - [Trie](<by_topic/Trie.md>) (18 completed)
 - [Binary Search](<by_topic/Binary Search.md>) (17 completed)
 - [Design](<by_topic/Design.md>) (17 completed)
-- [Dynamic Programming](<by_topic/Dynamic Programming.md>) (15 completed)
+- [Dynamic Programming](<by_topic/Dynamic Programming.md>) (16 completed)
 - [Heap (Priority Queue)](<by_topic/Heap (Priority Queue).md>) (15 completed)
 - [Recursion](<by_topic/Recursion.md>) (14 completed)
 - [Backtracking](<by_topic/Backtracking.md>) (13 completed)
 - [Counting](<by_topic/Counting.md>) (13 completed)
-- [Binary Search Tree](<by_topic/Binary Search Tree.md>) (11 completed)
+- [Binary Search Tree](<by_topic/Binary Search Tree.md>) (12 completed)
 - [Prefix Sum](<by_topic/Prefix Sum.md>) (10 completed)
 - [Sliding Window](<by_topic/Sliding Window.md>) (10 completed)
 - [Queue](<by_topic/Queue.md>) (8 completed)

markdowns/Questions_By_Code_Length.md

@@ -0,0 +1,41 @@
+# 104. [Maximum Depth of Binary Tree](<https://leetcode.com/problems/maximum-depth-of-binary-tree>)
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 04, 2024*
+>
+> *Last updated : July 04, 2024*
+
+
+------
+
+> **Related Topics** : **Tree, Depth-First Search, Breadth-First Search, Binary Tree**
+>
+> **Acceptance Rate** : **75.538 %**
+
+
+------
+
+*To see the question prompt, click the title.*
+
+## 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/Questions_By_Recent.md

@@ -0,0 +1,53 @@
+# 110. [Balanced Binary Tree](<https://leetcode.com/problems/balanced-binary-tree>)
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 04, 2024*
+>
+> *Last updated : July 04, 2024*
+
+
+------
+
+> **Related Topics** : **Tree, Depth-First Search, Binary Tree**
+>
+> **Acceptance Rate** : **52.384 %**
+
+
+------
+
+*To see the question prompt, click the title.*
+
+## 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
+```
+

markdowns/Topics.md

@@ -0,0 +1,61 @@
+# 124. [Binary Tree Maximum Path Sum](<https://leetcode.com/problems/binary-tree-maximum-path-sum>)
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 04, 2024*
+>
+> *Last updated : July 04, 2024*
+
+
+------
+
+> **Related Topics** : **Dynamic Programming, Tree, Depth-First Search, Binary Tree**
+>
+> **Acceptance Rate** : **40.121 %**
+
+
+------
+
+*To see the question prompt, click the title.*
+
+## Solutions
+
+- [h124.py](<../my-submissions/h124.py>)
+### Python
+#### [h124.py](<../my-submissions/h124.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 maxPathSum(self, root: Optional[TreeNode]) -> int:
+        # Schema: (longest independent, longestChain)
+        def helper(curr: Optional[TreeNode]) -> Tuple[int, int] :
+            if not curr :
+                return (None, None)
+            if not curr.left and not curr.right :
+                return (curr.val, curr.val)
+
+            leftInd, leftChn = helper(curr.left)
+            rightInd, rightChn = helper(curr.right)
+
+            independentCandidates = [curr.val]
+            chainCandidates = [0]
+            if leftInd != None :
+                independentCandidates.append(leftInd)
+                independentCandidates[0] += max(0, leftChn)
+                chainCandidates.append(leftChn)
+            if rightInd != None :
+                independentCandidates.append(rightInd)
+                independentCandidates[0] += max(0, rightChn)
+                chainCandidates.append(rightChn)
+
+            return (max(independentCandidates), max(chainCandidates) + curr.val)
+        return max(helper(root))
+```
+

markdowns/_104. Maximum Depth of Binary Tree.md

@@ -0,0 +1,61 @@
+# 1448. [Count Good Nodes in Binary Tree](<https://leetcode.com/problems/count-good-nodes-in-binary-tree>)
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 04, 2024*
+>
+> *Last updated : July 04, 2024*
+
+
+------
+
+> **Related Topics** : **Tree, Depth-First Search, Breadth-First Search, Binary Tree**
+>
+> **Acceptance Rate** : **73.019 %**
+
+
+------
+
+*To see the question prompt, click the title.*
+
+## Solutions
+
+- [m1448.java](<../my-submissions/m1448.java>)
+### Java
+#### [m1448.java](<../my-submissions/m1448.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 int goodNodes(TreeNode root) {
+        return goodNodesHelper(root, Integer.MIN_VALUE);
+    }
+    private int goodNodesHelper(TreeNode curr, int maxPrevious) {
+        int output = (curr.val >= maxPrevious) ? 1 : 0;
+        int maxx = Integer.max(curr.val, maxPrevious);
+        if (curr.left != null) {
+            output += goodNodesHelper(curr.left, maxx);
+        }
+        if (curr.right != null) {
+            output += goodNodesHelper(curr.right, maxx);
+        }
+        return output;
+    }
+}
+```
+

markdowns/_110. Balanced Binary Tree.md

@@ -0,0 +1,101 @@
+# 199. [Binary Tree Right Side View](<https://leetcode.com/problems/binary-tree-right-side-view>)
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 04, 2024*
+>
+> *Last updated : July 04, 2024*
+
+
+------
+
+> **Related Topics** : **Tree, Depth-First Search, Breadth-First Search, Binary Tree**
+>
+> **Acceptance Rate** : **63.274 %**
+
+
+------
+
+*To see the question prompt, click the title.*
+
+## Solutions
+
+- [m199.cpp](<../my-submissions/m199.cpp>)
+- [m199.java](<../my-submissions/m199.java>)
+### C++
+#### [m199.cpp](<../my-submissions/m199.cpp>)
+```C++
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<int> rightSideView(TreeNode* root) {
+        vector<int> output;
+        rsvHelper(root, 0, &output);
+        return output;
+    }
+
+    void rsvHelper(TreeNode* curr, int depth, vector<int>* output) {
+        if (not curr)
+            return;
+        if (depth == output->size())
+            output->push_back(curr->val);
+        
+        depth++;
+        rsvHelper(curr->right, depth, output);
+        rsvHelper(curr->left, depth, output);
+    }
+};
+```
+
+### Java
+#### [m199.java](<../my-submissions/m199.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<Integer> rightSideView(TreeNode root) {
+        List<Integer> output = new LinkedList<>();
+        rsvHelper(root, 0, output);
+        return output;
+    }
+
+    private void rsvHelper(TreeNode curr, int depth, List<Integer> output) {
+        if (curr == null) {
+            return;
+        }
+        if (depth == output.size()) {
+            output.add(curr.val);
+        }
+
+        depth++;
+        rsvHelper(curr.right, depth, output);
+        rsvHelper(curr.left, depth, output);
+    }
+}
+```
+