Problem 104 (#21)

* add solution and resources

* update readme

Author: curtisbarnard

README.md

@@ -28,7 +28,7 @@ As I work through this list I figure I would make a GitHub repo with my solution
 20. [Add Binary #67](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/add-binary-67.md)
 21. [Diameter of Binary Tree #543](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/diameter-binary-tree-543.md)
 22. [Middle of the Linked List #876](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/middle-linked-list-876.md)
-23. Maximum Depth of Binary Tree #104
+23. [Maximum Depth of Binary Tree #104](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/depth-binary-tree-104.md)
 24. Contains Duplicate #217
 
 ### Medium
@@ -106,13 +106,15 @@ In order to practice with similar data structures I'll be placing each problem i
 - [Invert Binary Tree #226](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/invert-binary-tree-226.md)
 - [Flood Fill #733](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/flood-fill-733.md)
 - [Implement Queue using Stacks #232](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/implement-queue-stacks-232.md)
+- [Maximum Depth of Binary Tree #104](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/depth-binary-tree-104.md)
 
 ### Stack
 
 - [Valid Parentheses #20](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/valid-parentheses-20.md)
 - [Invert Binary Tree #226](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/invert-binary-tree-226.md)
 - [Flood Fill #733](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/flood-fill-733.md)
 - [Implement Queue using Stacks #232](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/implement-queue-stacks-232.md)
+- [Maximum Depth of Binary Tree #104](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/depth-binary-tree-104.md)
 
 ### Linked Lists
 
@@ -139,6 +141,7 @@ In order to practice with similar data structures I'll be placing each problem i
 - [Lowest Common Ancestor of a Binary Search Tree #235](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/lowest-common-ancestor-235.md)
 - [Balanced Binary Tree #110](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/balanced-binary-tree-110.md)
 - [Diameter of Binary Tree #543](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/diameter-binary-tree-543.md)
+- [Maximum Depth of Binary Tree #104](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/depth-binary-tree-104.md)
 
 ## Algorithm Patterns
 
@@ -160,6 +163,7 @@ Within the problems above there are several patterns that often occur. I plan to
 
 - [Invert Binary Tree #226](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/invert-binary-tree-226.md)
 - [Flood Fill #733](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/flood-fill-733.md)
+- [Maximum Depth of Binary Tree #104](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/depth-binary-tree-104.md)
 
 ### Tree Depth First Search
 
@@ -168,6 +172,7 @@ Within the problems above there are several patterns that often occur. I plan to
 - [Lowest Common Ancestor of a Binary Search Tree #235](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/lowest-common-ancestor-235.md)
 - [Balanced Binary Tree #110](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/balanced-binary-tree-110.md)
 - [Diameter of Binary Tree #543](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/diameter-binary-tree-543.md)
+- [Maximum Depth of Binary Tree #104](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/depth-binary-tree-104.md)
 
 ### Divide & Conquer
 

easy/depth-binary-tree-104.md

@@ -0,0 +1,109 @@
+# Maximum Depth of Binary Tree
+
+Page on leetcode: https://leetcode.com/problems/maximum-depth-of-binary-tree/
+
+## Problem Statement
+
+Given the root of a binary tree, return its maximum depth. A binary tree's maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
+
+### Constraints
+
+- The number of nodes in the tree is in the range [0, 104].
+- -100 <= Node.val <= 100
+
+### Example
+
+```
+Input: root = [3,9,20,null,null,15,7]
+Output: 3
+```
+
+```
+Input: root = [1,null,2]
+Output: 2
+```
+
+## Solution
+
+Either DFS or BFS for traversal, I would select DFS. Recursion seems like the simplest way to approach. Edge cases would be null root or entire left branch null.
+
+### Initial Pseudocode
+
+1. Create max variable
+2. Create recursive function
+3. if node is null return 0
+4. Create a count variable equal to a recursive call
+5. Set max equal to max(max, count)
+6. return 1
+7. Call recursive function
+8. return max
+
+### Initial Solution
+
+This solution has a time and space complexity of O(n).
+
+```javascript
+const maxDepth = function (root) {
+  if (!root) {
+    return 0;
+  }
+
+  const depthLeft = maxDepth(root.left);
+  const depthRight = maxDepth(root.right);
+  return 1 + Math.max(depthLeft, depthRight);
+};
+```
+
+### Optimized Solution
+
+These alternative solutions have the same time and space complexity as above. You can see an explanation of the solutions here: https://www.youtube.com/watch?v=hTM3phVI6YQ
+
+```javascript
+// Breadth-First Search
+const maxDepth = function (root) {
+  if (!root) {
+    return 0;
+  }
+
+  const queue = [root];
+  let depth = 0;
+  while (queue.length > 0) {
+    const levelLength = queue.length;
+    for (let i = 0; i < levelLength; i++) {
+      const node = queue.shift();
+      if (node?.left) {
+        queue.push(node.left);
+      }
+      if (node?.right) {
+        queue.push(node.right);
+      }
+    }
+    depth++;
+  }
+
+  return depth;
+};
+
+// Iterative Depth-First Search
+const maxDepth = function (root) {
+  if (!root) {
+    return 0;
+  }
+
+  const stack = [[root, 1]];
+  let max = 0;
+  while (stack.length > 0) {
+    const [node, depth] = stack.pop();
+    max = Math.max(max, depth);
+
+    if (node?.left) {
+      stack.push([node.left, depth + 1]);
+    }
+    if (node?.right) {
+      stack.push([node.right, depth + 1]);
+    }
+  }
+
+  return max;
+};
+```