"Day 31 of #100DaysOfCode: LeetCode 104 - Maximum Depth of Binary Tree"

✅ Day 31 of #100DaysOfCode Challenge 📘 LeetCode Problem 104: 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. Example: Input: root = [3,9,20,null,null,15,7]   Output: 3 Explanation: The longest path is 3 → 20 → 7, so the depth = 3. --- 💡 Approach: We can solve this using Recursion — If the tree is empty → depth = 0 Recursively find the depth of the left and right subtrees The maximum depth = 1 + max(leftDepth, rightDepth) --- 💻 Java Code: class Solution {   public int maxDepth(TreeNode root) {     if (root == null)       return 0;     int leftDepth = maxDepth(root.left);     int rightDepth = maxDepth(root.right);     return 1 + Math.max(leftDepth, rightDepth);   } } --- ⚙ Complexity Analysis: ⏱ Time Complexity: O(n) → Each node is visited once 💾 Space Complexity: O(h) → Call stack height (h = height of tree) --- 🌱 Another small step in the 100 Days of Code journey! #100DaysOfCode #Day31 #LeetCode #Java #DSA #CodingChallenge #BinaryTree #Recursion

✅ Day 31 of #100DaysOfCode Challenge 📘 LeetCode Problem 104: 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. Example: Input: root = [3,9,20,null,null,15,7]   Output: 3 Explanation: The longest path is 3 → 20 → 7, so the depth = 3. --- 💡 Approach: We can solve this using Recursion — If the tree is empty → depth = 0 Recursively find the depth of the left and right subtrees The maximum depth = 1 + max(leftDepth, rightDepth) --- 💻 Java Code: class Solution {   public int maxDepth(TreeNode root) {     if (root == null)       return 0;     int leftDepth = maxDepth(root.left);     int rightDepth = maxDepth(root.right);     return 1 + Math.max(leftDepth, rightDepth);   } } --- ⚙ Complexity Analysis: ⏱ Time Complexity: O(n) → Each node is visited once 💾 Space Complexity: O(h) → Call stack height (h = height of tree) --- 🌱 Another small step in the 100 Days of Code journey! #100DaysOfCode #Day31 #LeetCode #Java #DSA #CodingChallenge #BinaryTree #Recursion

✅ Day 34 of #100DaysOfCode Challenge 📘 LeetCode Problem 111: Minimum Depth of Binary Tree 🧩 Problem Statement: Given a binary tree, find its minimum depth. The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node. Example: Input: root = [3,9,20,null,null,15,7] Output: 2 Explanation: The shortest path is 3 → 9, so the minimum depth = 2. 💡 Approach (Simple Recursive): If the tree is empty → return 0. Recursively find the left and right subtree depths. If one side is missing, the depth = 1 + depth of the other side. Otherwise, take 1 + min(leftDepth, rightDepth). 💻 Java Code (Easy Version): class Solution { public int minDepth(TreeNode root) { if (root == null) return 0; int left = minDepth(root.left); int right = minDepth(root.right); // If one child is missing, take the non-null side if (left == 0 || right == 0) return 1 + left + right; return 1 + Math.min(left, right); } } ⚙️ Complexity: ⏱️ Time: O(n) → visit each node once 💾 Space: O(h) → recursion stack (h = height of tree) 🌿 Growing one problem at a time 🌱 #Day34 #100DaysOfCode #LeetCode #Java #DSA #BinaryTree #Recursion #CodingChallenge #ProblemSolving

✅ Day 34 of #100DaysOfCode Challenge 📘 LeetCode Problem 111: Minimum Depth of Binary Tree 🧩 Problem Statement: Given a binary tree, find its minimum depth. The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node. Example: Input: root = [3,9,20,null,null,15,7] Output: 2 Explanation: The shortest path is 3 → 9, so the minimum depth = 2. 💡 Approach (Simple Recursive): If the tree is empty → return 0. Recursively find the left and right subtree depths. If one side is missing, the depth = 1 + depth of the other side. Otherwise, take 1 + min(leftDepth, rightDepth). 💻 Java Code (Easy Version): class Solution { public int minDepth(TreeNode root) { if (root == null) return 0; int left = minDepth(root.left); int right = minDepth(root.right); // If one child is missing, take the non-null side if (left == 0 || right == 0) return 1 + left + right; return 1 + Math.min(left, right); } } ⚙️ Complexity: ⏱️ Time: O(n) → visit each node once 💾 Space: O(h) → recursion stack (h = height of tree) 🌿 Growing one problem at a time 🌱 #Day34 #100DaysOfCode #LeetCode #Java #DSA #BinaryTree #Recursion #CodingChallenge #ProblemSolving

✅ Day 34 of #100DaysOfCode Challenge 📘 LeetCode Problem 111: Minimum Depth of Binary Tree 🧩 Problem Statement:  Given a binary tree, find its minimum depth. The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node. Example: Input: root = [3,9,20,null,null,15,7] Output: 2 Explanation:  The shortest path is 3 → 9, so the minimum depth = 2. 💡 Approach (Simple Recursive): If the tree is empty → return 0. Recursively find the left and right subtree depths. If one side is missing, the depth = 1 + depth of the other side. Otherwise, take 1 + min(leftDepth, rightDepth). 💻 Java Code (Easy Version): class Solution {   public int minDepth(TreeNode root) {     if (root == null)       return 0;     int left = minDepth(root.left);     int right = minDepth(root.right);     // If one child is missing, take the non-null side     if (left == 0 || right == 0)       return 1 + left + right;     return 1 + Math.min(left, right);   } } ⚙ Complexity: ⏱ Time: O(n) → visit each node once 💾 Space: O(h) → recursion stack (h = height of tree) 🌿 Growing one problem at a time 🌱  #Day34 #100DaysOfCode #LeetCode #Java #DSA #BinaryTree #Recursion #CodingChallenge #ProblemSolving

✅ Day 33 of #100DaysOfCode Challenge 📘 LeetCode Problem 110: Balanced Binary Tree 🧩 Problem Statement:  Given a binary tree, determine if it is height-balanced. A height-balanced binary tree is a binary tree in which the depth of the two subtrees of every node never differs by more than 1. Example: Input: root = [3,9,20,null,null,15,7] Output: true Explanation:  Both left and right subtrees of every node differ in height by at most 1. 💡 Approach (Simple & Efficient): Use a recursive function to calculate the height of each subtree. If any subtree is unbalanced, return -1. Otherwise, return the height of the tree. If the final result is -1 → tree is not balanced. 💻 Java Code: class Solution {   public boolean isBalanced(TreeNode root) {     return checkHeight(root) != -1;   }   private int checkHeight(TreeNode node) {     if (node == null) return 0;     int leftHeight = checkHeight(node.left);     if (leftHeight == -1) return -1;     int rightHeight = checkHeight(node.right);     if (rightHeight == -1) return -1;     if (Math.abs(leftHeight - rightHeight) > 1) return -1;     return 1 + Math.max(leftHeight, rightHeight);   } } ⚙ Complexity: ⏱ Time: O(n) → Each node visited once 💾 Space: O(h) → Recursion stack (h = tree height) 🌱 Another step towards mastering Binary Trees!  #Day33 #100DaysOfCode #LeetCode #Java #DSA #BinaryTree #BalancedTree #Recursion #CodingChallenge

📅 Day 81 of #100DaysOfLeetCode Problem: Insert into a Binary Search Tree (LeetCode #701) Approach: The task is to insert a new node with a given value into a Binary Search Tree (BST). Start from the root and recursively find the correct position: If the new value is smaller than the current node’s value, go to the left subtree. Otherwise, go to the right subtree. When a null spot is found, insert a new node there. The BST property is preserved throughout this process. Complexity: ⏱️ Time: O(h) — where h is the height of the tree. 💾 Space: O(h) — recursive call stack. 🔗 Problem Link: https://lnkd.in/dCS7zxVG 🔗 Solution Link: https://lnkd.in/dxB4ZNtV #LeetCode #100DaysOfCode #BinarySearchTree #Recursion #Java #TreeTraversal #DSA #Algorithms #CodingChallenge #ProblemSolving #CodeNewbie #StudyWithMe #BuildInPublic #LearnToCode #DailyCoding

🚀 Day 45 of #LeetCode100DaysChallenge Solved LeetCode 7: Reverse Integer 🔢 🧩 Problem Statement: Given a 32-bit signed integer x, return its digits reversed. If reversing x causes it to overflow (i.e., go beyond the signed 32-bit integer range), return 0. 💡 Approach: Used Mathematical logic with overflow checks. 1️⃣ Extract the last digit using modulo (x % 10). 2️⃣ Append it to the reversed number (rev * 10 + digit). 3️⃣ Before adding, check if multiplying by 10 causes overflow/underflow using Integer.MAX_VALUE and Integer.MIN_VALUE. 4️⃣ Continue until all digits are processed. ⚙️ Complexity: Time: O(log₁₀(n)) → Each digit processed once. Space: O(1) ✨ Key Takeaways: ✅ Learned how to handle integer overflow cleanly in Java. ✅ Practiced mathematical manipulation without using string conversion. ✅ Reinforced understanding of signed 32-bit integer range. #LeetCode #100DaysOfCode #Java #ProblemSolving #CodingChallenge #DSA #InterviewPreparation #TechLearning #CodeNewbie #WomenInTech

✅ Day 33 of #100DaysOfCode Challenge 📘 LeetCode Problem 110: Balanced Binary Tree 🧩 Problem Statement: Given a binary tree, determine if it is height-balanced. A height-balanced binary tree is a binary tree in which the depth of the two subtrees of every node never differs by more than 1. Example: Input: root = [3,9,20,null,null,15,7] Output: true Explanation: Both left and right subtrees of every node differ in height by at most 1. 💡 Approach (Simple & Efficient): Use a recursive function to calculate the height of each subtree. If any subtree is unbalanced, return -1. Otherwise, return the height of the tree. If the final result is -1 → tree is not balanced. 💻 Java Code: class Solution { public boolean isBalanced(TreeNode root) { return checkHeight(root) != -1; } private int checkHeight(TreeNode node) { if (node == null) return 0; int leftHeight = checkHeight(node.left); if (leftHeight == -1) return -1; int rightHeight = checkHeight(node.right); if (rightHeight == -1) return -1; if (Math.abs(leftHeight - rightHeight) > 1) return -1; return 1 + Math.max(leftHeight, rightHeight); } } ⚙️ Complexity: ⏱️ Time: O(n) → Each node visited once 💾 Space: O(h) → Recursion stack (h = tree height) 🌱 Another step towards mastering Binary Trees! #Day33 #100DaysOfCode #LeetCode #Java #DSA #BinaryTree #BalancedTree #Recursion #CodingChallenge

✅ Day 33 of #100DaysOfCode Challenge 📘 LeetCode Problem 110: Balanced Binary Tree 🧩 Problem Statement: Given a binary tree, determine if it is height-balanced. A height-balanced binary tree is a binary tree in which the depth of the two subtrees of every node never differs by more than 1. Example: Input: root = [3,9,20,null,null,15,7] Output: true Explanation: Both left and right subtrees of every node differ in height by at most 1. 💡 Approach (Simple & Efficient): Use a recursive function to calculate the height of each subtree. If any subtree is unbalanced, return -1. Otherwise, return the height of the tree. If the final result is -1 → tree is not balanced. 💻 Java Code: class Solution { public boolean isBalanced(TreeNode root) { return checkHeight(root) != -1; } private int checkHeight(TreeNode node) { if (node == null) return 0; int leftHeight = checkHeight(node.left); if (leftHeight == -1) return -1; int rightHeight = checkHeight(node.right); if (rightHeight == -1) return -1; if (Math.abs(leftHeight - rightHeight) > 1) return -1; return 1 + Math.max(leftHeight, rightHeight); } } ⚙️ Complexity: ⏱️ Time: O(n) → Each node visited once 💾 Space: O(h) → Recursion stack (h = tree height) 🌱 Another step towards mastering Binary Trees! #Day33 #100DaysOfCode #LeetCode #Java #DSA #BinaryTree #BalancedTree #Recursion #CodingChallenge