LeetCode Same Tree Problem Solved with BFS

🚀 Day 54 / 100 – LeetCode Challenge ✅ Solved: Same Tree (Easy) Today’s problem was about comparing two binary trees and checking whether they are structurally identical with the same node values. 🔍 Key Idea: Used Recursion to traverse both trees simultaneously: If both nodes are null → same If one is null → not same If values match → recursively check left & right subtrees 💡 This problem strengthened my understanding of: Tree Traversal Recursion Base Case Handling ⚡ Performance: ⏱ Runtime: 0 ms (Beats 100%) 💾 Memory: 43.07 MB Consistency is the key - one problem closer to the goal! 💪 #Day54 #LeetCode #DSA #BinaryTree #Java #CodingJourney #Consistency

Day 41 of Daily DSA 🚀 Solved LeetCode 20: Valid Parentheses ✅ Problem: Given a string containing only (), {}, [], determine if the input string is valid. Rules: Open brackets must be closed by the same type Open brackets must be closed in the correct order Every closing bracket must have a matching opening bracket Approach: Used a Stack to track opening brackets and validate matching pairs. Steps: Traverse the string Push opening brackets onto the stack For closing brackets → check top of stack If it matches → pop Else → return false At the end, stack should be empty ⏱ Complexity: • Time: O(n) • Space: O(n) 📊 LeetCode Stats: • Runtime: 3 ms (Beats 87.41%) ⚡ • Memory: 43.37 MB A classic stack problem that builds strong fundamentals for expression parsing & validation. #DSA #LeetCode #Java #Stack #ProblemSolving #CodingJourney #Consistency

🧠 Day 30 / 100 – DSA Practice Solved Remove Duplicates from Sorted List on LeetCode 🔗✅ 🔹 Problem Insight: Given a sorted linked list, remove duplicates so each element appears only once. 🔹 Approach: Used a single pointer traversal: Compared current node with next node Skipped duplicate nodes by updating links Leveraged the fact that the list is already sorted 🔹 Complexity: Time → O(n) Space → O(1) 💯 Result: ✔️ All test cases passed ⚡ Runtime: 0 ms (Beats 100%) Consistency builds confidence 💪🚀 #Day30 #100DaysOfCode #LeetCode #Java #DSA #LinkedList #CodingJourney #ProblemSolving

🚀 Day 62 of #100DaysOfCode 🌱 Topic: Trees / Recursion ✅ Problem Solved: LeetCode 112 – Path Sum 🛠 Approach: Used DFS (recursion) to explore all root-to-leaf paths. Base Case: If node is null → return false If leaf node: Check if target == node.val → return result Otherwise: Reduce target → target - node.val Recurse on left and right subtree #100DaysOfCode #Day62 #DSA #Trees #Recursion #DFS #LeetCode #Java #BinaryTree #ProblemSolving #CodingJourney #Consistency

Day 68 of My DSA Journey Today’s problem: Symmetric Tree 🌳 Problem Statement Given a binary tree, check whether it is a mirror of itself (symmetric around its center). Key Insight A tree is symmetric if: Left subtree is a mirror of the right subtree Compare nodes in a cross manner: Left → Left with Right → Right Left → Right with Right → Left 🧠 Approach Use recursion to compare two nodes at a time Base cases: If both nodes are null → symmetric If one is null → not symmetric Check: Values are equal Outer and inner pairs match ⚡ Complexity Time: O(n) Space: O(h) (recursion stack) ✨ What I Learned This problem improved my understanding of recursion and how to think in terms of mirror structures instead of normal traversal. Consistency is the key 🔑 — one problem at a time! #DSA #Java #BinaryTree #CodingJourney #100DaysOfCode

🧠 Day 32 / 100 – DSA Practice Solved Symmetric Tree on LeetCode 🌳✅ 🔹 Problem: Check whether a binary tree is a mirror of itself (symmetric around its center). 🔹 Approach: Used a recursive mirror check: Compare left subtree with right subtree Check if: ✔️ Values are equal ✔️ Left of one == Right of other ✔️ Right of one == Left of other 🔁 Recursively verified symmetry at each level 🔹 Complexity: ⏱ Time → O(n) 📦 Space → O(n) (recursion stack) 💯 Result: ✔️ All test cases passed ⚡ Runtime: 0 ms (Beats 100%) Understanding recursion patterns in trees is getting stronger day by day 🚀 #Day32 #100DaysOfCode #LeetCode #Java #DSA #BinaryTree #Recursion #CodingJourney

🚀 Day 70 of #100DaysOfCode Solved 107. Binary Tree Level Order Traversal II on LeetCode 🔗 🧠 Key Insight: This is just level order traversal (BFS) but: 👉 Return levels from bottom to top instead of top to bottom ⚙️ Approach (DFS with Level Tracking): 1️⃣ Start traversal with level = 0 2️⃣ For each node: 🔹 If level not present → insert new list at front 🔹 Add value at correct position: 👉 res.get(res.size() - 1 - level) 3️⃣ Recurse: 🔹 Left → level + 1 🔹 Right → level + 1 ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(n) #100DaysOfCode #LeetCode #DSA #BinaryTree #BFS #DFS #Java #InterviewPrep #CodingJourney

Day 44🚀 Solved Number of Islands — a classic DFS/BFS problem that really tests grid traversal and thinking in connected components. 💡 Key Takeaways: Learned how to treat the grid like a graph Used DFS to explore and mark visited land Strengthened understanding of recursion + boundary handling ⚡ Result: ✅ All test cases passed ⏱️ Optimized runtime 📈 Improving problem-solving speed day by day Consistency > Motivation. Showing up daily is the real win. #Day44 #LeetCode #DSA #Java #CodingJourney #Consistency #ProblemSolving

Another step forward in my DSA journey 🚀 After going through the basics, I’ve now started Arrays — and today was all about understanding how they actually work under the hood. 💡 Key takeaway: Arrays are stored in the heap, but each array itself is allocated as a continuous block of memory — making indexing fast and efficient. Also explored: • Why arrays are needed • Internal working & memory representation • Dynamic memory allocation • null & default values in Java • for-each loop & toString() • Arrays of objects • Passing arrays in functions Small concept, big clarity. This is where real problem-solving starts. #DSA #Java #LearningInPublic #Consistency #CodingJourney

Day 64/75 — Reverse Bits Today’s problem was about reversing the bits of a 32-bit integer. Approach: • Iterate through all 32 bits • Shift result left to make space • Extract last bit using (n & 1) • Add it to result • Right shift n Core idea: result <<= 1; result |= (n & 1); n >>= 1; Time Complexity: O(1) (fixed 32 iterations) Space Complexity: O(1) Bit manipulation getting sharper ⚡ 64/75 #Day64 #DSA #BitManipulation #Java #LeetCode