Univalued Binary Tree: DFS Approach

🚀 Day 125 of #LeetCode Challenge! Problem: Binary Tree Preorder Traversal 💡 My Approach: The goal is to perform a preorder traversal of a binary tree — visiting nodes in the order: Root → Left → Right Here’s the step-by-step logic: Start from the root node. Visit (record) the root value first. Recursively traverse the left subtree, then the right subtree. Store values in a vector as you go. ✨ Example Input: [1, null, 2, 3] Output: [1, 2, 3] 🧠 Key Idea Preorder traversal is useful when you need to copy or serialize a tree — it captures the structure starting from the root. ⏱ Complexity TypeValueTimeO(N) — each node visited onceSpaceO(H) — recursion stack (H = height of tree) 📎 GitHub Link: https://lnkd.in/gZ6GeXzm #LeetCode #BinaryTree #PreorderTraversal #Recursion #DSA #C++ #ProblemSolving #CodingChallenge #Day125

🚀 Day 124 of #LeetCode Challenge! Problem: Binary Tree Inorder Traversal 💡 My Approach: The goal is to perform an inorder traversal of a binary tree — visiting nodes in the order: Left → Root → Right. Here’s how I implemented it: Use recursion to traverse the tree. Start from the root node. Recursively visit the left subtree, then record the root value, and finally traverse the right subtree. This ensures all nodes are visited in sorted order for a BST. ✨ Example Input: [1, null, 2, 3] Output: [1, 3, 2] 🧠 Key Idea Inorder traversal naturally retrieves nodes in ascending order if the tree is a Binary Search Tree (BST). ⏱ Complexity TypeValueTimeO(N) — each node visited onceSpaceO(H) — recursion stack (H = height of tree) 📎 GitHub Link: https://lnkd.in/gBgJShhT #LeetCode #BinaryTree #InorderTraversal #Recursion #DSA #C++ #ProblemSolving #CodingChallenge #Day124

🚀 Day 115 of #LeetCode Challenge! Problem: Symmetric Tree 🌳 Concept: Check whether a binary tree is a mirror of itself (i.e., symmetric around its center). 💡 My Approach: Use recursion to compare left and right subtrees. A tree is symmetric if: Left subtree of left node matches right subtree of right node Right subtree of left node matches left subtree of right node Base cases: Both nodes NULL → symmetric ✅ One NULL and one not → not symmetric ❌ Values must match ✨ Example: Input: [1,2,2,3,4,4,3] Output: true ⏱ Time Complexity: O(N) — visiting all nodes 📦 Space Complexity: O(H) — recursion stack (H = height of tree) 📌 Key Insight: This is a classic mirror check — left's left must mirror right's right! 👨💻 GitHub Link: https://lnkd.in/gid6xjvn #LeetCode #BinaryTree #Recursion #SymmetricTree #MirrorTree #DSA #ProblemSolving #C++ #CodingChallenge #Day114

🚀 Day 114 of #LeetCode Challenge! Problem: Symmetric Tree 🌳 Concept: Check whether a binary tree is a mirror of itself (i.e., symmetric around its center). 💡 My Approach: Use recursion to compare left and right subtrees. A tree is symmetric if: Left subtree of left node matches right subtree of right node Right subtree of left node matches left subtree of right node Base cases: Both nodes NULL → symmetric ✅ One NULL and one not → not symmetric ❌ Values must match ✨ Example: Input: [1,2,2,3,4,4,3] Output: true ⏱ Time Complexity: O(N) — visiting all nodes 📦 Space Complexity: O(H) — recursion stack (H = height of tree) 📌 Key Insight: This is a classic mirror check — left's left must mirror right's right! 👨💻 GitHub Link: https://lnkd.in/grXFRA2i #LeetCode #BinaryTree #Recursion #SymmetricTree #MirrorTree #DSA #ProblemSolving #C++ #CodingChallenge #Day114

🚀 Day 127 of #LeetCode Challenge! Problem: Binary Tree Level Order Traversal 💡 My Approach: This problem involves traversing the binary tree level by level — also known as Breadth-First Search (BFS) traversal. Here’s the step-by-step breakdown: Use a queue to store nodes level by level. For each level, store all node values in a temporary list. Push their left and right children into the queue. After finishing one level, add it to the result vector. ✨ Example Input: [3,9,20,null,null,15,7] Output: [[3], [9,20], [15,7]] 🧠 Key Idea This traversal captures the hierarchical structure of the tree perfectly — often used in problems involving level-based processing, like Zigzag traversal or average of levels. ⏱ Complexity TypeValueTimeO(N) — each node visited onceSpaceO(N) — for queue and result storage 📎 GitHub Link: https://lnkd.in/gntMrKbU #LeetCode #BinaryTree #BFS #LevelOrderTraversal #DSA #ProblemSolving #C++ #CodingChallenge #100DaysOfCode #Day127

🚀 Day 112 of #LeetCode Challenge! Problem: Diameter of Binary Tree 💡 My Approach: The diameter of a binary tree is the longest path between any two nodes (may or may not pass through the root). The trick is to calculate the height of each subtree while keeping track of the maximum left + right path encountered. Use a helper function height() that: Recursively computes left and right subtree heights. Updates the global diameter as the maximum sum of left and right heights. ✨ Example: Input: [1,2,3,4,5] Output: 3 Explanation: The longest path is [4,2,1,3] or [5,2,1,3] ⏱ Time Complexity: O(N) — visit every node once 💾 Space Complexity: O(H) — recursive stack (H = height of tree) 🌱 Key Insight: At each node, the longest path through it is leftHeight + rightHeight. The overall diameter is the maximum of all such paths. 👨💻 GitHub Link: https://lnkd.in/dvUDMZUC #LeetCode #BinaryTree #Recursion #TreeTraversal #DSA #CodingChallenge #C++ #Day112

🚀 Day 22 of #Blind75 Challenge 🎯 Problem: Invert Binary Tree 🧩 Platform: LeetCode (#226) 💡 Category: Binary Tree / DFS 🧠 Problem Statement Given the root of a binary tree, invert it so that every left child becomes the right child and vice-versa. Example: Input: 4 / \ 2 7 / \ / \ 1 3 6 9 Output: 4 / \ 7 2 / \ / \ 9 6 3 1 💡 Intuition This is one of the cleanest examples of how powerful recursive DFS can be. At each node: Swap its left and right child Recursively invert the left subtree Recursively invert the right subtree The structure updates itself naturally using recursion — no additional data structure required. ⚙️ Complexity ⏱ Time: O(n) — visiting each node once 💾 Space: O(h) — recursion stack (h = tree height) ✨ Key Takeaway Binary tree problems become drastically simpler once you recognize how recursion naturally matches the tree’s structure. “Invert Binary Tree” is the perfect warm-up to mastering tree traversals, DFS, and recursion patterns. 📚 Full solutions at my LeetCode profile: 👉 https://lnkd.in/gGEwKNFV #Blind75 #LeetCode #Java #BinaryTrees #DFS #DSA #CodingChallenge #SoftwareEngineering #ProblemSolving #CareerGrowth #100DaysOfCode

🚀LeetCode Daily Challenge 🧩 Problem: Smallest Number With All Set Bits Problem Intuition: Given an integer n, your task is to find the smallest number that has the same number of bits as n when represented in binary, but with all bits set to 1. In simple terms — if n requires k bits to represent, you must find the smallest integer whose binary form has exactly k ones (111...1). 💡Example Insight: Let’s say n = 6 → Binary: 110 → requires 3 bits. The smallest number with all 3 bits set to 1 is 111 → which is 7 in decimal. Hence, the answer is 7. 🧠 Approach & Strategy: ✔ First, determine the number of bits needed to represent n: res = floor(log2(n)) + 1. ✔ Then, iterate from n to an upper limit and check for the first number having exactly res set bits. ✔ The check is performed using the built-in function __builtin_popcount(x) which counts the number of 1’s in the binary representation. ✔ Return the first number satisfying this condition. ⚙️ Complexity Analysis: Time Complexity: O(k) → Iterates until the matching number is found (within small bounds). Space Complexity: O(1) → Uses only integer variables. 🔗Problem: https://lnkd.in/dwR7Gp8i 💻 Solution: https://lnkd.in/dJU6Wrra #LeetCode #DSA #Cpp #ProblemSolving #CodingChallenge #LeetCodeDailyChallenge

🚀LeetCode Daily Challenge 🧩 Problem: Delete Nodes From Linked List Present in Array Problem Intuition: Given a linked list and an array of integers, you need to remove all nodes from the linked list whose values are present in the given array. In simple terms, delete every node that matches any number in the array and return the updated linked list. 💡Example Insight: Let’s say: nums = [1, 2, 3] Linked List = 1 → 2 → 4 → 3 → 5 After removing nodes with values 1, 2, and 3, the linked list becomes: 4 → 5 🧠 Approach & Strategy: ✔ Store all numbers from the array nums into an unordered_set for quick lookup (O(1) average). ✔ Traverse the linked list, and for each node: Skip it if its value is present in the set. Otherwise, add it to the new linked list. ✔ Finally, return the head of this new linked list. ⚙️ Complexity Analysis: Time Complexity: O(n + m) → n = length of linked list, m = size of array. Space Complexity: O(m) → For storing array elements in a set. 🔗 Problem: https://lnkd.in/dWA2hsDr 💻 Solution: https://lnkd.in/dypBvguK #LeetCode #DSA #Cpp #ProblemSolving #CodingChallenge #LeetCodeDailyChallenge

🚀 LeetCode Daily Challenge – Problem 81: Search in Rotated Sorted Array II Today I solved an interesting problem that tests both binary search optimization and edge case handling in rotated arrays. 🔍 Problem Summary: We’re given a rotated sorted array (which may contain duplicates) and need to determine whether a given target exists in it. 💡 Approach: Use a modified binary search to handle the rotation and duplicate values. If the middle element matches the target, return true. When duplicates are present (nums[low] == nums[mid] == nums[high]), adjust both ends to skip redundancy. Determine which side (left or right) is properly sorted and move the search boundaries accordingly. Continue until the target is found or the range is exhausted #LeetCode #DSA #CodingJourney #BinarySearch #ProblemSolving #CPlusPlus #StriversDSASheet ---