Java Arrays Fundamentals: Day 9 of 100 Days of DSA

Day 4/100 – Data Structures & Algorithms Problems Solved: • Reverse Linked List • Remove Nth Node from End of List • String to Integer (atoi) Concepts Practiced: • Linked List pointer manipulation • Two-pointer technique • String parsing and edge case handling Key Learning: Many Linked List problems become efficient when using the two-pointer approach, especially for operations involving positions from the end. Continuing the journey of improving problem-solving skills while preparing for backend development roles. #100DaysOfCode #DSA #LeetCode #Java #BackendDevelopment

70 LeetCode problems solved. Focused on building a strong foundation in Data Structures & Algorithms through consistent daily practice. Progress so far: • Covered core topics: Arrays, Strings, Recursion, Backtracking • Started solving medium-level problems regularly • Improving problem-solving approach and pattern recognition Approach: • Solve first, then analyze better solutions • Focus on patterns, not just individual questions Staying locked in on the process. #LeetCode #DSA #Java #ProblemSolving #Consistency

Day 35/75 — Generate Parentheses (Backtracking) Today’s problem was about generating all valid combinations of parentheses. Instead of brute force, I used backtracking with constraints. Key conditions: • Add '(' if open < n • Add ')' if close < open Base case: if (open == n && close == n) This ensures only valid sequences are generated. Time Complexity: ~ O(2ⁿ) Space Complexity: O(n) This problem helped strengthen my understanding of recursive decision trees. 35/75 🚀 #Day35 #DSA #Backtracking #Java #Algorithms #LeetCode

#day332 of #1001daysofcode problem statement (0226): Invert Binary Tree The idea is to recursively swap the left and right child of every node in the tree. ⏱ Time Complexity: O(n) 🧠 Space Complexity: O(h) — recursion stack (h = height of tree) #1001DaysOfCode #DSA #Java #LeetCode #ProblemSolving Shivam Mahajan #leetcode

#day333 of #1001daysofcode problem statement (0257): Binary Tree Paths 💡 Approach: Used DFS recursion to explore all root-to-leaf paths in the binary tree. While traversing, I kept building the path string. When a leaf node is reached, the complete path is added to the result list. Example path format: 1->2->5 ⏱ Time Complexity: O(n) 🧠 Space Complexity: O(h) — recursion stack (h = height of the tree) Consistency in solving one problem every day 📈 #1001DaysOfCode #DSA #Java #LeetCode #ProblemSolving Shivam Mahajan #leetcode

🚀 Day 33 of #GFG60 — Staying Consistent Today’s problem: Length of Longest Cycle in a Graph 🔍 Key Concepts: • Graph traversal • Cycle detection using HashMap • Tracking visit order to compute cycle length • Efficient O(V) approach 💡 Learned how to detect cycles and calculate their length without redundant traversals. Consistency is starting to compound 📈 33 days in — no breaks. #GeeksforGeeks #DSA #CodingJourney #Java #GraphTheory #Consistency #KeepGrinding

🌱 Day 26 of #100DaysOfCode 🚀 📍 Day 26 Progress Started with the core concept of two pointers and how it helps in reducing time complexity for sorted data structures. ✅Worked on problems based on: 📌Prefix Sum 📌Finding pair sum equal to a target in two sorted arrays . Prefix Sum still needs more practice to gain stronger clarity and confidence, especially while handling edge cases. Building pattern recognition step by step 💙 #100DaysOfCode #DSA #TwoPointers #PrefixSum #Java #RevisionMode #LearningInPublic #Consistency

Day 3/100 – Data Structures & Algorithms Problems Solved: • Largest Time for Given Digits • Palindrome Linked List • Middle of the Linked List • Remove Linked List Elements • Linked List Cycle Concepts Practiced: • Linked List traversal • Fast & Slow pointer technique • Basic backtracking • Two-pointer pattern Key Learning: Linked List problems often become simpler when using the fast and slow pointer technique for traversal and cycle detection. Building consistency one day at a time while preparing for backend development roles. #100DaysOfCode #DSA #LeetCode #Java #BackendDevelopment

Day 18 of #100DaysOfDSA (Java) Today I explored Divide and Conquer, a powerful problem-solving technique used in many efficient algorithms. Topics covered: 🔹 Merge Sort (stable, O(n log n)) 🔹 Quick Sort (efficient average case sorting) 🔹 Searching in a Sorted & Rotated Array 🔹 Understanding how problems can be broken into smaller subproblems and solved recursively Key takeaway: Divide and Conquer is not just about sorting — it’s about thinking recursively and optimizing solutions by reducing problem size. Also realized the importance of choosing the right algorithm: Merge Sort → stable and predictable Quick Sort → faster in practice but depends on pivot Day 18 From basic logic → to algorithmic thinking. #DSA #Java #DivideAndConquer #MergeSort #QuickSort #100DaysOfCode #ProblemSolving #DeveloperJourney

🚀 DSA Consistency - Day 57 Today I solved the Same Tree problem on LeetCode, which focuses on understanding binary tree structure comparison using recursion. The goal is to determine whether two binary trees are structurally identical and have the same node values. 🧠 Approach: Recursive Tree Traversal To check if two trees are the same: 1️⃣ If both nodes are null, they are identical → return true. 2️⃣ If one node is null and the other is not, trees differ → return false. 3️⃣ If node values are different, trees are not identical. 4️⃣ Recursively check: Left subtree of both trees Right subtree of both trees Both must match for the trees to be identical. ⏱ Complexity Analysis Time Complexity: O(n) Each node is visited once. Space Complexity: O(h) Due to recursion stack (where h is the height of the tree). #DSA #LeetCode #BinaryTree #Java #CodingJourney #Consistency #ProblemSolving #100DaysOfCode