Reversing k-Group Nodes in a Linked List with Java

Day 29/100 – #100DaysOfCode 🚀 | #Java #LeetCode #BinaryTree ✅ Problem Solved: Verify Preorder Serialization of a Binary Tree 🌲 🧩 Problem Summary: Given a string representing a preorder serialization of a binary tree, determine if it’s valid. Example: "9,3,4,#,#,1,#,#,2,#,6,#,#" → ✅ valid "1,#" → ❌ invalid 💡 Approach Used: Used the slot-counting method 🧠 Each node uses one slot and non-null nodes create two new slots. Process the preorder string, ensuring slots never go negative and exactly zero remain at the end. ⚙️ Time Complexity: O(n) 📦 Space Complexity: O(1) ✨ Takeaway: This problem teaches how binary tree structure can be validated with simple counting logic — no need to rebuild the tree! 🌱 #Java #LeetCode #BinaryTree #100DaysOfCode #ProblemSolving #CodingChallenge

Day 39/100 – #100DaysOfCode 🚀 | #Java #LeetCode #HashMap ✅ Problem Solved: Minimum Index Sum of Two Lists 🧩 Problem Summary: Given two string arrays, find the common strings with the smallest index sum (index in list1 + index in list2). If multiple answers exist, return all of them. 💡 Approach Used: ➤ Stored the elements of the first list in a HashMap with their indices. ➤ Iterated the second list and checked for matches. ➤ Tracked the minimum index sum and collected all strings that match that sum. This avoids nested loops and improves efficiency. ⚙️ Time Complexity: O(n + m) 📦 Space Complexity: O(n) ✨ Takeaway: HashMaps continue to be one of the most effective tools for reducing time complexity through direct lookups 🔍⚡ #Java #LeetCode #HashMap #DataStructures #ProblemSolving #100DaysOfCode #CodingJourney

Day 50/100 – #100DaysOfCode 🚀 | #Java #Arrays #GreedyApproach ✅ Problem Solved: Minimum Operations to Convert All Elements to Zero (LeetCode) 🧩 Problem Summary: You’re given an array of integers. In one operation, you can subtract the smallest non-zero value from every non-zero element. Return the number of operations needed to make all elements zero. 💡 Approach Used: Instead of simulating operations (which would be inefficient), observe: Each distinct positive value in the array contributes exactly one operation. Because removing the smallest non-zero repeatedly is equivalent to counting how many unique positive values exist. So, Answer = Count of unique positive elements Why this works: Each distinct positive number represents one “level” of reduction until zero. ⚙️ Time Complexity: O(N) 📦 Space Complexity: O(N) (for set) ✨ Takeaway: This problem highlights how pattern recognition and mathematical simplification often outperform brute-force logic. #Java #LeetCode #MathLogic #GreedyAlgorithm #ProblemSolving #100DaysOfCode #CodingChallenge

Day 45/100 – #100DaysOfCode 🚀 | #Java #Hashing #SlidingWindow ✅ Problem Solved: Contains Duplicate III (LeetCode 220) 🧩 Problem Summary: Given an integer array and integers k and t, determine if there exist two distinct indices i and j such that: |i - j| ≤ k |nums[i] - nums[j]| ≤ t 💡 Approach Used: Used a Sliding Window + TreeSet to maintain numbers in a sorted structure. Steps: Traverse the array and maintain a window of at most size k. For each element x, find if there exists another element in the set such that |x - y| ≤ t. This is done using ceiling() to find the closest value ≥ x. Insert the element in TreeSet and remove the element that slides out. ⚙️ Time Complexity: O(n log k) 📦 Space Complexity: O(k) ✨ Takeaway: This problem teaches how ordered data structures like TreeSet help efficiently handle range queries in sliding window scenarios. #Java #TreeSet #SlidingWindow #LeetCode #ProblemSolving #100DaysOfCode #CodingChallenge

#100DaysOfCode – Day 85 Delete the Middle Node of a Linked List Problem Statement: Given the head of a singly linked list, delete the middle node and return the modified list. My Approach: Used two-pointer technique (slow & fast) to identify the middle node in a single traversal. Maintained a prev pointer to skip the middle node without extra space. Carefully handled the edge case when the list has only one node. Complexity: Time: O(N) Space: O(1) Linked lists are all about pointers and precision a small mistake (like an extra semicolon ";") can make a huge difference. Understanding how slow and fast pointers move gives deep insight into efficient traversal patterns. #LeetCode #100DaysOfCode #Java #LinkedList #ProblemSolving #takeUforward #CodingJourney #DataStructures #CodeNewbie

#100DaysOfCode – Day 80 Reverse Linked List Problem: Given the head of a singly linked list, reverse the list and return the reversed version. Example: Input: [1, 2, 3, 4, 5] Output: [5, 4, 3, 2, 1] My Approach: Used an iterative method to reverse the list efficiently by manipulating pointers. Initialized three pointers prev, temp, and front. Iteratively reversed each node’s direction until the end of the list was reached. Returned prev as the new head of the reversed list. Time Complexity: O(N) Space Complexity: O(1) Reversing a linked list might look tricky at first, but once you understand pointer manipulation it’s pure logic and flow. #takeUforward #100DaysOfCode #DSA #Java #ProblemSolving #LeetCode #LinkedList #Pointers #CodeNewbie

Day 51/100 – #100DaysOfCode 🚀 | #Java #LinkedList #Heap ✅ Problem Solved: Merge k Sorted Lists (LeetCode) 🧩 Problem Summary: You’re given k sorted linked lists. The task is to merge them into one sorted linked list. 💡 Approach Used: Use a Min-Heap (PriorityQueue) to always pick the node with the smallest value among all current heads of the lists. Steps: Push the head of each non-null list into the Min-Heap. Extract the smallest, attach to result, and push its next node (if exists). Continue until heap becomes empty. This ensures efficient merging. ⚙️ Time Complexity: O(N log k) 📦 Space Complexity: O(k) ✨ Takeaway: When multiple sorted streams exist, heaps provide clean and optimal merging. #Java #LeetCode #Heap #LinkedList #ProblemSolving #CodingChallenge #100DaysOfCode

🚀 𝐃𝐚𝐲 9 𝐨𝐟 𝐦𝐲 #100𝐃𝐚𝐲𝐬𝐎𝐟𝐃𝐒𝐀 𝐉𝐨𝐮𝐫𝐧𝐞𝐲 𝐏𝐫𝐨𝐛𝐥𝐞𝐦𝐬 𝐒𝐨𝐥𝐯𝐞𝐝 𝐓𝐨𝐝𝐚𝐲 : 🔥 1️⃣ Leetcode (Medium) – Product of Array Except Self 💡 Key Idea: Instead of using division, use Prefix and Suffix Products. Prefix → product of all elements before the current index Suffix → product of all elements after the current index Multiply both to get the result for each element. 🧾 Time Complexity: O(n) ⚙️ Space Complexity: O(1) #DSA #Java #100DaysOfCode #ProblemSolving #LearningInPublic #SortingAlgorithms #CodingJourney

Day 48/100 – #100DaysOfCode 🚀 | #Java #Backtracking #Recursion ✅ Problem Solved: Palindrome Partitioning (LeetCode 131) 🧩 Problem Summary: Given a string s, partition it such that every substring in the partition is a palindrome. Return all possible palindrome partitioning combinations. 💡 Approach Used: Used Backtracking to explore all possible substring splits. Key Idea: At each position, expand and check if the substring s[start…i] is a palindrome. If yes → include it and recurse for the rest of the string. If no → skip and continue searching. Helper Components: Recursive DFS function for exploring partitions. A fast palindrome-checking utility. ⚙️ Time Complexity: O(N × 2ⁿ) 📦 Space Complexity: O(N) (recursion stack + path building) ✨ Takeaway: This problem strengthens understanding of recursion tree exploration, decision branching, and string-based backtracking. #Java #LeetCode #Backtracking #Recursion #ProblemSolving #100DaysOfCode #CodingChallenge

@Value + Lifecycle Annotations The @Value annotation injects constants, property values, or expressions. It simplifies configuration by externalizing values cleanly. With @PostConstruct, you can initialize resources after dependencies load. @PreDestroy helps you release resources before shutdown. Together they ensure smooth object setup and cleanup. #SpringFramework #Java #SoftwareEngineering #BackendDevelopment