Improved 104

Author: javadev

src/main/java/g0101_0200/s0104_maximum_depth_of_binary_tree/readme.md

@@ -37,39 +37,30 @@ A binary tree's **maximum depth** is the number of nodes along the longest path
 *   The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.
 *   `-100 <= Node.val <= 100`
 
-To solve this problem in Java with a `Solution` class, we'll use a depth-first search (DFS) traversal approach. Below are the steps:
+To solve the "Maximum Depth of Binary Tree" problem in Java with a `Solution` class, we'll perform a depth-first search (DFS) traversal of the binary tree. Below are the steps:
 
 1. **Create a `Solution` class**: Define a class named `Solution` to encapsulate our solution methods.
 
 2. **Create a `maxDepth` method**: This method takes the root node of the binary tree as input and returns its maximum depth.
 
-3. **Check for null root**: Check if the root is null. If so, return 0, as an empty tree has a maximum depth of 0.
+3. **Check for null root**: Check if the root is null. If it is, return 0 as the depth.
 
-4. **Recursively calculate the maximum depth**: Define a helper method `dfs` to recursively calculate the maximum depth of the binary tree.
-   - If the current node is null, return 0.
-   - Otherwise, recursively calculate the maximum depth of the left and right subtrees.
-   - Return the maximum depth of the left and right subtrees, plus 1 (to account for the current node).
+4. **Perform DFS traversal**: Recursively compute the depth of the left and right subtrees. The maximum depth of the binary tree is the maximum depth of its left and right subtrees, plus 1 for the current node.
 
-5. **Return the maximum depth**: After traversing the entire tree, return the maximum depth calculated.
+5. **Return the result**: After the DFS traversal is complete, return the maximum depth of the binary tree.
 
 Here's the Java implementation:
 
 ```java
 class Solution {
     public int maxDepth(TreeNode root) {
         if (root == null) return 0; // Check for empty tree
-        return dfs(root); // Recursively calculate maximum depth
+        int leftDepth = maxDepth(root.left); // Compute depth of left subtree
+        int rightDepth = maxDepth(root.right); // Compute depth of right subtree
+        return Math.max(leftDepth, rightDepth) + 1; // Return maximum depth of left and right subtrees, plus 1 for the current node
     }
 
-    // Helper method to recursively calculate maximum depth
-    private int dfs(TreeNode node) {
-        if (node == null) return 0;
-        int leftDepth = dfs(node.left); // Calculate maximum depth of left subtree
-        int rightDepth = dfs(node.right); // Calculate maximum depth of right subtree
-        return Math.max(leftDepth, rightDepth) + 1; // Return maximum depth plus 1 for current node
-    }
-    
-    // TreeNode definition
+    // Definition for a TreeNode
     public class TreeNode {
         int val;
         TreeNode left;
@@ -86,4 +77,4 @@ class Solution {
 }
 ```
 
-This implementation follows the steps outlined above and efficiently solves the problem of finding the maximum depth of a binary tree in Java.
+This implementation follows the steps outlined above and efficiently computes the maximum depth of the binary tree in Java using DFS traversal.