Improving Problem-Solving Skills with Data Structures in Java

🚀 Day 44 of my #100DaysOfCode Journey Today, I solved the LeetCode problem: Find the Least Frequent Digit Problem Insight: Find the digit (0–9) that appears the least number of times in a given number. Approach: • Used a frequency array of size 10 to store digit counts • Extracted digits using modulo and division • Traversed the frequency array to find the minimum occurring digit • Returned the smallest digit in case of tie Time Complexity: • O(n) Space Complexity: • O(1) (fixed size array of 10) Key Learnings: • Arrays are more efficient than HashMap when range is limited • Digit extraction using % 10 is very useful in number problems • Keeping track of minimum efficiently avoids extra passes Takeaway: Simple logic + right data structure = clean and optimal solution #DSA #Java #LeetCode #100DaysOfCode #CodingJourney #ProblemSolving

🚀Day 16 of #128DaysOfCode Solved a classic stack-based problem today! 🔍 Problem: Validate whether a string containing brackets "() {} []" is properly balanced. 💡 Approach: Used a Stack (LIFO) to track opening brackets and match them with corresponding closing brackets. - Push opening brackets - On closing bracket → check top of stack - If mismatch or stack is empty → invalid - At the end, stack should be empty This problem highlights how stacks are perfect for handling nested structures and order-based validation 🧠 Key Learnings: ✔ Strengthened understanding of Stack data structure ✔ Learned how to handle edge cases like mismatched and unordered brackets ✔ Improved problem-solving approach for string-based questions ⏱ Complexity: Time → O(n) Space → O(n) Consistency is the key 🔥 On to Day 17 💪 #DSA #Java #LeetCode #Stack #ProblemSolving #CodingJourney #PlacementsPreparation

Day 79 of My DSA Journey Today’s problem was a fun twist on data structures: Implementing a Stack using Queues At first, it seems counterintuitive since: Stack follows LIFO (Last In First Out) Queue follows FIFO (First In First Out) So the challenge was to make a queue behave like a stack. 💡 What I Did I used two queues and rearranged elements during the push operation so that the most recent element always stays at the front. ⚙️ How It Works Insert the new element into a helper queue Move all existing elements into it Swap the queues This ensures that stack operations like pop() and top() work efficiently. ⏱ Complexity Push → O(n) Pop → O(1) Top → O(1) 🧠 Key Takeaways Data structures are flexible when you understand their behavior Problem-solving is about adapting concepts creatively Even simple structures can lead to interesting challenges Consistency is the real game changer 💪 Looking forward to solving more such problems! #Day79 #DSA #Java #CodingJourney #ProblemSolving #Consistency #TechJourney

Day 86 – Binary Tree Level Order Traversal Worked on traversing a binary tree level by level using a queue-based approach (Breadth-First Search). Key Learnings: Learned to use a queue (FIFO) for level-wise traversal of trees Understood how to process nodes layer by layer using queue size Strengthened understanding of tree traversal patterns and data structure usage #DSA #Java #BinaryTree #BFS #Queue #ProblemSolving #CodingPractice

🚀 Day 25 of #100DaysOfDSA (Java) Today I explored Queue, an important linear data structure that follows the FIFO (First In First Out) principle. Covered: 🔹 Introduction to Queue 🔹 Queue implementation using arrays and Linked List 🔹 Queue operations (enqueue, dequeue, peek) 🔹 Circular Queue concept 🔹 Understanding difference between Stack and Queue Key takeaway: Unlike stacks, queues process elements in order, making them useful for scheduling, buffering, and real-world scenarios like task management systems. Also learned how queues are widely used in algorithms like Breadth-First Search (BFS). Day 25 ✅ Expanding understanding of core data structures. #DSA #Java #Queue #DataStructures #100DaysOfCode #ProblemSolving #DeveloperJourney #LearningInPublic

🚀Day 40 LeetCode 1161 – Maximum Level Sum of a Binary Tree Ever wondered how to find the level of a binary tree with the maximum sum of node values? 🤔 Here’s the idea: We traverse the tree level by level (BFS) and compute the sum at each level. The trick is to keep track of the maximum sum and return the smallest level where this occurs. 💡 Key Insight: Level-order traversal (using a queue) naturally processes nodes one level at a time, making it perfect for this problem. 🔧 Approach: ✔ Use a queue for BFS ✔ For each level:     • Calculate sum of nodes ✔ Track maximum sum and corresponding level 🔥 Takeaway: Whenever a problem involves levels in a tree, think BFS first — it often leads to the cleanest solution. #LeetCode #DataStructures #Java #CodingInterview #BinaryTree #BFS #ProblemSolving

🚀 Day 43 of my #100DaysOfCode Journey Today, I solved the LeetCode problem: Sum of Unique Elements Problem Insight: Find elements in an array that appear exactly once and calculate their total sum. Approach: • Used a frequency array to count occurrences of each number • Traversed the array to build frequency • Added only those elements to sum whose frequency is exactly 1 Time Complexity: • O(n) Space Complexity: • O(1) (fixed size array used for constraints) Key Learnings: • Frequency array is faster than HashMap when range is fixed • Two-pass approach makes logic clear and simple • Always check constraints before choosing data structure Takeaway: Right data structure makes the solution simple and efficient 🚀 #DSA #Java #LeetCode #100DaysOfCode #CodingJourney #ProblemSolving

Day 67/100 | #100DaysOfDSA 🧩🚀 Today’s problem: Subsets II Another classic backtracking problem with a twist (duplicates). Problem idea: Generate all possible subsets (power set), but avoid duplicate subsets. Key idea: Backtracking + sorting to handle duplicates. Why? • We need to explore all subset combinations • Duplicates in input can lead to duplicate subsets • Sorting helps us skip repeated elements efficiently How it works: • Sort the array first • At each step, add current subset to result • Iterate through elements • Skip duplicates using condition: 👉 if (i > start && nums[i] == nums[i-1]) continue • Choose → recurse → backtrack Time Complexity: O(2^n) Space Complexity: O(n) recursion depth Big takeaway: Handling duplicates in backtracking requires careful skipping logic, not extra data structures. This pattern appears in many problems (subsets, permutations, combinations). 🔥 Day 67 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #Backtracking #Recursion #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity

Today I solved LeetCode 958 – Check Completeness of a Binary Tree. 🧩 Problem Summary: Given the root of a binary tree, determine if it is a complete binary tree. A complete binary tree is defined as: All levels are completely filled except possibly the last level In the last level, nodes are as far left as possible 💡 Key Concepts Used: Binary Trees Breadth First Search (BFS) Queue data structure Tree properties 🧠 Approach: Use BFS (level order traversal) with a queue. Traverse nodes level by level. Once a null node is encountered: All following nodes must also be null. If a non-null node appears after a null, the tree is not complete. Otherwise, the tree satisfies completeness. ⏱ Time Complexity: O(N) — Each node is visited once. 📚 What I Learned: Understanding the properties of a complete binary tree. Using BFS to validate structural constraints. Handling null conditions carefully during traversal. Strengthening queue-based tree problem-solving. Building strong fundamentals in tree structures Consistency is key to mastering DSA #LeetCode #DSA #BinaryTree #CompleteBinaryTree #BFS #Queue #Java #CodingJourney #ProblemSolving #100DaysOfCode #TechGrowth

🚀 Day 5 – Code Wild Kickoff Series: Reverse Linked List 🔄 Today’s challenge focused on one of the most fundamental and frequently asked data structure problems: Reversing a Singly Linked List. 🧩 Problem Statement Given the beginning of a singly linked list head, reverse the list and return the new beginning of the list. 📌 Examples • Input: [0, 1, 2, 3] Output: [3, 2, 1, 0] • Input: [] Output: [] 📌 Constraints • 0 <= length of the list <= 1000 • -1000 <= Node.val <= 1000 💡 Approach The idea is to reverse the direction of the next pointers while traversing the list. 1. Initialize • prev = null • curr = head 2. Iterate through the list • Store the next node: nextTemp = curr.next • Reverse the pointer: curr.next = prev • Move prev and curr one step forward. 3. Return • When traversal ends, prev becomes the new head of the reversed list. ✅ Edge Cases Handled • Empty list (head == null) → Returns null. • Single node list → Remains unchanged. • General case → All links are reversed in place with O(n) time and O(1) space complexity. #Day5 #CodeWild #100DaysOfCode #DSA #LinkedList #Java #CodingJourney #TechLearning #InterviewPrep