Binary Search Tree Fundamentals in Java

🌳 Day 56/100: Search in BST - New Data Structure Unlocked Day 56. Started learning Binary Search Trees today. First problem: Search. Clean and simple. 🎯 📌 Problem: Search for a value in a Binary Search Tree. 💡 BST Property: Left subtree < Node < Right subtree This makes searching O(log n)! 🎯 The Logic: If val == root → Found it! If val < root → Go left If val > root → Go right Repeat until found or null No need to check both sides. BST structure guides us directly to the answer. 📊 Complexity: O(h) where h = height 🌱 New Territory: After weeks of arrays, strings, stacks—finally trees! Different structure, same problem-solving mindset. Day 56. Trees unlocked. 🌳 #100DaysOfCode #DSA #LeetCode #Day56 #Java #BinarySearchTree #TreeProblems #NewDataStructure From linear to hierarchical! 🌳✨

🔹 Day 3 – DSA Consistency Journey Today, I solved LeetCode 693: Binary Number with Alternating Bits independently as part of my structured Data Structures & Algorithms practice. The problem focuses on verifying whether a number’s binary representation contains alternating bits (e.g., 1010…). I implemented an efficient O(log n) approach by iterating through each bit and validating adjacent comparisons. Problems like these reinforce: * Strong understanding of bit manipulation * Logical thinking with binary representations * Writing clean and efficient solutions Small, consistent steps every day are helping me sharpen problem-solving skills and strengthen core fundamentals. You can view my solution here: 🔗 https://lnkd.in/dbhAwWSC Looking forward to continuing this consistency journey. #DSA #LeetCode #ProblemSolving #SoftwareEngineering #ContinuousLearning #Java

🚀 #100DaysOfCode – Day 27 Update Today I solved two DSA problems and explored different approaches. 🔹 Problem 1: Find Majority Element (n/2) ✅ Solved using Moore’s Voting Algorithm — an optimal approach. ⏱ Time Complexity: O(n) 💾 Space Complexity: O(1) 📌 Learned how voting/cancellation logic helps find the majority element efficiently without extra space. --- 🔹 Problem 2: Sort a Linked List ✅ Approach 1 — Brute Force - Traversed the linked list and stored all node data in a temporary ArrayList. - Sorted the ArrayList. - Traversed the linked list again and updated node values. ⏱ Time Complexity: O(n) + O(n log n) + O(n) ≈ O(n log n) 💾 Space Complexity: O(n) 📌 Understood how extra space can simplify logic but is not optimal. 🔥 Tomorrow I will explore the optimal approach for sorting a linked list. #Day27 #100DaysOfCode #DSA #LinkedList #Java #ProblemSolving #CodingJourney

I didn't expect a linked list concept in an array problem. But that's exactly what this was. 🚀 Day 59/365 — DSA Challenge Solved: Find the Duplicate Number The problem: Given n + 1 numbers Each number is in range [1, n] There is exactly one duplicate. Find it. Constraint: ❌ Can't modify array ❌ O(1) extra space only At first, this looks like an array problem. But the trick is... 👉 Treat it like a linked list 💡 Key idea: Each value points to an index nums[i] → next index This creates a cycle. And the duplicate number is the entry point of the cycle So I used: 👉 Floyd's Cycle Detection Algorithm (slow & fast pointers) Step 1: Move slow by 1 Move fast by 2 They will meet inside the cycle Step 2: Reset slow to start Move both by 1 Where they meet again = duplicate ⏱ O(n) time 📦 O(1) space This problem taught me: Sometimes the solution is not in the data structure you see... But in how you interpret it. Code 👇 https://lnkd.in/dad5sZfu #DSA #LearningInPublic #Java #LeetCode #ProblemSolving #Consistency

Even classic problems become powerful lessons when you focus on fundamentals. ✅ 🚀 #Day57 of #100DaysOfCodeChallenge Today was all about simulating real-world arithmetic using linked lists. A great reminder that data structures can mirror how we actually think about numbers. 📌 Problem 01: Add Two Numbers (Medium) Two numbers are given as linked lists where digits are stored in reverse order. The task is to add them and return the sum as a linked list. 🧠 Logic: Traverse both linked lists simultaneously. Add corresponding digits along with a carry. Store the result digit using modulo (sum % 10). Propagate carry using integer division (sum / 10). Use a dummy node to simplify list construction. Continue until both lists and carry are exhausted. Day 57 complete ✅ Still consistent. Still learning. 🚀 #100DaysOfCode #Day57 #LeetCode #DSA #LinkedList #Java #ProblemSolving #CodingJourney #LearnInPublic #Consistency

Day 53/100 – LeetCode Challenge ✅ Problem: #110 Balanced Binary Tree Difficulty: Easy Language: Java Approach: DFS with Early Termination Time Complexity: O(n) Space Complexity: O(h) where h = tree height Key Insight: Tree is balanced if for every node: Left and right subtrees are balanced Height difference ≤ 1 Use DFS to compute heights while checking balance condition. Return -1 as sentinel for unbalanced subtree. Solution Brief: Modified depth calculation to return -1 when imbalance detected. Checked left/right subtree heights at each node. If any subtree returns -1 or height difference > 1, propagate -1 upward. Final check: root depth ≠ -1 means tree is balanced. #LeetCode #Day53 #100DaysOfCode #DFS #Java #Algorithm #CodingChallenge #ProblemSolving #BalancedBinaryTree #EasyProblem #Tree #Recursion #DSA

Day 19 of Daily DSA 🚀 Solved LeetCode 2089: Find Target Indices After Sorting Array ✅ Approach: Instead of actually sorting the array, I counted: elements less than the target elements equal to the target The starting index is determined by how many elements are smaller than the target, and then indices are built for all equal elements. Simple counting → no extra sorting needed 💡 ⏱ Complexity: • Time: O(n) — single pass • Space: O(1) — excluding output list 📊 LeetCode Stats: • Runtime: 0 ms (Beats 100%) ⚡ • Memory: 44.83 MB (Beats 83.41%) A neat example of how thinking beyond “just sort it” can lead to cleaner and faster solutions. #DSA #LeetCode #Java #ProblemSolving #DailyCoding #Consistency #Arrays

Efficiency matters when working with data. This week, I focused on strengthening my understanding of searching techniques and traversal strategies. From basic sequential search to optimized tree-based approaches, each concept helped me understand how performance changes based on the data structure we choose. These implementations improved my clarity in: • Time complexity analysis • Choosing the right search strategy • Understanding traversal behavior in trees All solutions are implemented in Java with focus on clean logic and efficiency. 🔗 GitHub Repository: https://lnkd.in/gQHKDf7Z Step by step, building stronger fundamentals 🚀 #DSA #Java #Algorithms #SoftwareDevelopment #BFS #DFS #BinarySearch #LearningJourney #Consistency

🔥 Day 92 of #100DaysOfCode Today’s challenge: LeetCode – Search a 2D Matrix 🧩📊 📌 Problem Summary You are given a matrix where: Each row is sorted in ascending order The first element of each row is greater than the last element of the previous row 👉 This means the entire matrix behaves like a sorted 1D array. Goal: Return true if target exists, otherwise false. 🧠 Approach: Double Binary Search Instead of scanning row by row, we use Binary Search twice. Step 1️⃣: Find the Correct Row Binary search on rows: If target > last element of row → move down If target < first element of row → move up Otherwise → target must be inside this row Step 2️⃣: Binary Search Inside That Row 💡 Why This Works? Because: Rows are sorted Row ranges don’t overlap It behaves like a flattened sorted array. ⏱ Time Complexity: O(log m + log n) 💾 Space Complexity: O(1) 🚀 Performance Runtime: 0 ms Beats 100% submissions Memory: Very efficient 🔥 🧠 Key Learning Whenever: Data looks 2D But ordering behaves like 1D 👉 Think Binary Search Optimization Stack → Sliding Window → Queue → Binary Search → Matrix Search Patterns are connecting now 💪 On to Day 93 🚀 #100DaysOfCode #LeetCode #BinarySearch #Matrix #Java #DSA #InterviewPrep

🚀 #100DaysOfCode | Day 36 📌 LeetCode – Path Sum Today I solved the Path Sum problem using a recursive Depth-First Search (DFS) approach. Given a binary tree and a target sum, determine whether there exists a root-to-leaf path such that the sum of all node values equals the target. 💡 Approach: ✔ If the node is null, return false. ✔ If it's a leaf node, check whether the remaining sum equals the node value. ✔ Recursively subtract the current node value from targetSum. ✔ Check both left and right subtrees. ✔ If either returns true → path exists. ⏱ Complexity: Time Complexity: O(n) Space Complexity: O(h) — height of the tree Binary tree problems are all about mastering recursion and understanding base cases clearly. #Java #LeetCode #DSA #BinaryTree #Recursion #ProblemSolving