104. Maximum Depth of Binary Tree

MaximumDepthOfBinaryTree/step1.md

@@ -0,0 +1,43 @@
+```java
+// Use DFS, return depth when node don't have children
+// Increse depth before visit child node
+// Time complexity: O(N) N: number of node
+// Space complexity: O(N)
+// Time spend: 04:26
+class Solution {
+    public int maxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
+    }
+
+    // BFS
+    // Time spend: 04:30
+    public int maxDepthFindByBfs(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+
+        int maxDepth = 0;
+        while (!queue.isEmpty()) {
+            int queueSize = queue.size();
+            for (int i = 0; i < queueSize; i++) {
+                TreeNode curr = queue.poll();
+                if (curr.left != null) {
+                    queue.add(curr.left);
+                }
+                if (curr.right != null) {
+                    queue.add(curr.right);
+                }
+            }
+            maxDepth++;
+        }
+
+        return maxDepth;
+    }
+}
+```

MaximumDepthOfBinaryTree/step2.md

@@ -0,0 +1,41 @@
+```java
+class Solution {
+    public int maxDepth(TreeNode root) {
+        return maxDepthFindByBfs(root);
+    }
+
+    public int maxDepthFindByDfs(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        return Math.max(maxDepthFindByDfs(root.left), maxDepthFindByDfs(root.right)) + 1;
+    }
+
+    // BFS
+    // Time spend: 04:30
+    public int maxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        Queue<Pair<TreeNode, Integer>> queue = new LinkedList<>();
+        queue.add(new Pair(root, 1));
+
+        int maxDepth = 1;
+        while (!queue.isEmpty()) {
+            Pair<TreeNode, Integer> current = queue.poll();
+            maxDepth = Math.max(current.getValue(), maxDepth);
+
+            if (current.getKey().left != null) {
+                queue.add(new Pair(current.getKey().left, current.getValue() + 1));
+            }
+            if (current.getKey().right != null) {
+                queue.add(new Pair(current.getKey().right, current.getValue() + 1));
+            }
+        }
+
+        return maxDepth;
+    }
+}
+```

MaximumDepthOfBinaryTree/step3.md

@@ -0,0 +1,55 @@
+```java
+// Time spend: 02:11
+class Solution {
+    public int maxDepth(TreeNode root) {
+        return maxDepthByDfs(root, 1);
+    }
+
+    public int maxDepthByDfs(TreeNode root, int currentDepth) {
+        if (root == null) {
+            return currentDepth - 1;
+        }
+
+        int nextDepth = currentDepth + 1;
+        return Math.max(maxDepthByDfs(root.left, nextDepth),
+            maxDepthByDfs(root.right, nextDepth));
+    }
+}
+```
+
+```java
+// Time spend: 02:03
+class Solution {
+    public int maxDepth(TreeNode root) {
+        return maxDepthByDfs(root, 1);
+    }
+
+    public int maxDepthByDfs(TreeNode root, int currentDepth) {
+        if (root == null) {
+            return currentDepth - 1;
+        }
+
+        int nextDepth = currentDepth + 1;
+        return Math.max(maxDepthByDfs(root.left, nextDepth),
+            maxDepthByDfs(root.right, nextDepth));
+    }
+}
+```
+
+```java
+// Time spend: 01:42
+class Solution {
+    public int maxDepth(TreeNode root) {
+        return maxDepthByDfs(root, 1);
+    }
+
+    public int maxDepthByDfs(TreeNode root, int currentDepth) {
+        if (root == null) {
+            return currentDepth - 1;
+        }
+
+        int nextDepth = currentDepth + 1;
+        return Math.max(maxDepthByDfs(root.left, nextDepth), maxDepthByDfs(root.right, nextDepth));
+    }
+}
+```