How to Count Operations to Zero in 100 Days of LeetCode

🔹 DSA Daily | Check if Two Arrays are Equal At first glance, this problem looked simple — just compare two arrays, right? But then I realized, the order of elements doesn’t matter, only their frequency does. 💡 Problem Statement: Given two arrays, check if they contain the same elements with the same frequency, regardless of order. My Approach: I used unordered maps to count the frequency of each element in both arrays and then compared them. This small trick turned a potentially messy comparison into a clean and efficient solution. Time Complexity: O(n) — traversing both arrays once Space Complexity: O(n) — storing frequencies in hash maps Sometimes, a simple data structure like a hash map makes all the difference. It’s not just about solving the problem — it’s about writing elegant, efficient code. 🚀 #DSA #CPlusPlus #Coding #ProblemSolving #HashMap #Arrays #CodeEveryday #GeeksforGeeks #LeetCode #ProgrammingJourney #DataStructures #Algorithms #InterviewPrep #CodingCommunity #LogicBuilding #EfficientCode #LearnToCode #TechJourney

https://lnkd.in/gmysJzSq Today I solve the classic tree-recursion problem on LeetCode: “Same Tree”. The task was to determine if two binary trees are structurally identical and have the same node values. What I did Handled base cases: if both nodes are nullptr, return true; if one is nullptr and the other isn’t, return false. Recursively compared the left subtrees and right subtrees. Checked the current node values after the recursive calls. Ensured the solution is clean, simple, and efficient in terms of logic. Here’s the core solution snippet: /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} * }; */ class Solution { public: bool isSameTree(TreeNode* p, TreeNode* q) { if (p == nullptr && q == nullptr) return true; if (p == nullptr || q == nullptr) return false; bool leftSame = isSameTree(p->left, q->left); bool rightSame = isSameTree(p->right, q->right); return (p->val == q->val) && leftSame && rightSame; } }; Key Takeaways Recursive tree problems often boil down to base case checks + recursive calls on subtrees + combining results. Clean code is powerful: Fewer lines, clear logic, fewer errors (e.g., mis-using -> vs >). Regularly solving such problems builds strong fundamentals for more complex tree or graph challenges later on. #LeetCode #Cplusplus #TreeAlgorithm #DSA #ProblemSolving #CodingJourney #CleanCode #SoftwareEngineering

🔥 Day 116 of My DSA Challenge – Move Zeroes 🔷 Problem : 283. Move Zeroes 🔷 Goal : Move all 0s to the end of the array while maintaining the relative order of non-zero elements. Must be done in-place without using extra space. 🔷 Key Insight : This problem focuses on in-place array manipulation and pointer logic. We need to keep all non-zero elements in front and shift all zeros toward the end — but without disturbing their relative order. A simple and efficient solution is to use the two-pointer approach: One pointer (idx) scans through the array. Another pointer (k) keeps track of where the next non-zero should be placed. 🔷 Approach : 1️⃣ Initialize pointer k = 0 2️⃣ Traverse the array with index idx 3️⃣ If nums[idx] != 0, assign nums[k] = nums[idx] If k != idx, set nums[idx] = 0 to push zero backward Increment k 4️⃣ The array is now rearranged in-place Time Complexity: O(n) Space Complexity: O(1) This problem strengthens array manipulation and in-place optimization skills. Use pointers wisely — move only what’s needed, keep it clean, keep it fast. This logic is useful for : ✅ Partitioning problems ✅ Rearranging arrays ✅ In-place sorting optimizations Another small but meaningful win — one step closer to mastering the art of clean, efficient code 🚀 #Day116 #DSA #100DaysOfCode #LeetCode #TwoPointers #Arrays #ProblemSolving #Java #CodingChallenge #Algorithms #DataStructures #DeveloperJourney #EngineerMindset #LogicBuilding #GrowEveryday

🔹 DSA Daily | Find Equilibrium Point in an Array (C++) Today, I solved the **Equilibrium Point** problem — a classic question that tests your understanding of **prefix sums and array traversal**. 💡  Problem Statement:   Given an array, find the index where the **sum of elements on the left** is equal to the **sum of elements on the right**.   If no such point exists, return -1. Approach:   1️⃣ First, calculate the **total sum** of the array.   2️⃣ Traverse the array while keeping track of the **left sum**.   3️⃣ For each index, compute the **right sum** using the formula:     `right_sum = total_sum - left_sum - arr[i]`  4️⃣ If left_sum == right_sum, that index is the equilibrium point.  Time Complexity: O(n) — single traversal of the array   Space Complexity: O(1) — constant extra space  This problem reinforces how simple **mathematical logic** and **efficient iteration** can solve what looks like a tricky problem at first glance. 🚀  #DSA #CPlusPlus #Coding #ProblemSolving #Arrays #EquilibriumPoint #CodeEveryday #GeeksforGeeks #LeetCode #ProgrammingJourney #DataStructures #Algorithms #InterviewPrep #CodingCommunity #LogicBuilding #EfficientCode #LearnToCode #TechJourney

Day 68 of My DSA Challenge Problem: Check whether a given string containing brackets — {}, [], () — is balanced. Example: {[()]} → Balanced {[(])} → Not Balanced Approach Used: → Implemented using a Stack data structure. → Traverse each character in the string:   • If it’s an opening bracket — push it into the stack.   • If it’s a closing bracket — check if the top of the stack matches the corresponding opening bracket. → If it matches, pop the top element; otherwise, the string is unbalanced. → After traversal, if the stack is empty — the string is balanced. Key Idea: Stacks are perfect for this problem because of their LIFO (Last In, First Out) behavior — the last opened bracket should be the first one to close. Time Complexity: O(N) Space Complexity: O(N) Pattern: Stack / Parenthesis Matching #Day68 #DSAChallenge #Stacks #BalancedParentheses #ProblemSolving #JavaCoding #DataStructures #Algorithms #GeeksforGeeks #160DaysOfCode #CodingJourney #LearnDSA #DSAWithJava #CodingCommunity

Day 64 of My DSA Challenge Problem: Find the Product of Array Elements Except Self without using the division operator. Example: Input: arr = [1, 2, 3, 4] Output: [24, 12, 8, 6] (Explanation: For index 0 → 2×3×4 = 24 For index 1 → 1×3×4 = 12, and so on.) Approach Used: → We can’t use division here, so we maintain two cumulative products: Prefix Product: Product of all elements before the current index. Suffix Product: Product of all elements after the current index. → Multiply both prefix and suffix products for each index to get the final result. → This avoids division and gives O(N) time with O(N) extra space. Time Complexity: O(N) Space Complexity: O(N) Key Insight: Optimizing constraints (like “no division allowed”) pushes you to think in terms of prefix–suffix relationships, a very common and powerful pattern in DSA. #Day64 #DSAChallenge #CodingInJava #ProductOfArrayExceptSelf #PrefixSuffix #ProblemSolving #ArrayAlgorithms #Hashing #GeeksforGeeks #CodeOptimization #160DaysOfCode #LearnDSA #DataStructures #Algorithms #CodingJourney #TechGrowth #ProblemSolver #JavaProgramming

https://lnkd.in/gYKr9A3J Today I solved an interesting Binary Tree problem on LeetCode: “Subtree of Another Tree”. The task was to determine whether one binary tree (subRoot) is a subtree of another (root). This problem reinforced the importance of recursion and tree traversal techniques. My Approach: Wrote a helper function isIndentical to check if two trees are exactly the same. In isSubtree, recursively checked for every node in the main tree whether the subtree matches. Carefully handled null cases to avoid runtime errors. Here’s my C++ implementation: /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} * }; */ class Solution { public: bool isIndentical(TreeNode* p, TreeNode* q){ if(p == NULL && q == NULL) return true; if(p == NULL || q == NULL) return false; return p->val == q->val && isIndentical(p->left, q->left) && isIndentical(p->right, q->right); } bool isSubtree(TreeNode* root, TreeNode* subRoot) { if(root == NULL) return false; if(isIndentical(root, subRoot)) return true; return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot); } }; Key Takeaways: Recursion is a powerful tool for tree problems. Always handle null cases carefully to avoid runtime errors. Writing a clean helper function can simplify complex problems. #LeetCode #CPlusPlus #BinaryTree #DSA #ProblemSolving #CodingJourney #TreeAlgorithms #SoftwareEngineering

🌟 Day 82 – Count Good Nodes in Binary Tree Challenge! 🌟 Today’s challenge explores an elegant recursive problem that reinforces your understanding of Depth-First Search (DFS) and state propagation through recursive calls — counting “good” nodes in a binary tree. 🌳 A good node is one that is greater than or equal to all the values from the root to that node, making this problem perfect for mastering recursive state tracking and conditional logic in trees. 🔹 Problem: Count Good Nodes in Binary Tree Given the root of a binary tree, return the number of nodes X where the value of X is greater than or equal to every value on the path from the root to X. Example: 3 / \ 1 4 / / \ 3 1 5 Output: ✅ 4 Explanation: Nodes 3 (root), 3 (left child), 4, and 5 are “good” since they are not smaller than any node along their respective root paths. ⚡ Approach: Top-Down DFS Traversal with Maximum Tracking 1️⃣ Perform a DFS traversal starting from the root. 2️⃣ Carry along the maximum value seen so far in the current path. 3️⃣ If the current node’s value ≥ max seen so far → count it as “good”. 4️⃣ Update the max and recursively continue for both left and right children. 💡 Key Insights: - Follows a Top-Down recursion pattern — decisions at each node depend on data passed from parent to child. - Demonstrates how to carry state information (max value) through recursive calls. - A simple yet powerful example of using recursion for conditional aggregation. - Builds intuition for dynamic programming on trees and path-based logic problems. 📉 Complexity Analysis: ⏱ Time Complexity: O(N) — each node is visited once. 💾 Space Complexity: O(H) — recursion stack proportional to tree height. 🔗 LeetCode Problem: 1448. Count Good Nodes in Binary Tree - https://lnkd.in/giir7hvs 📂 Code Repository: Count Good Nodes in Binary Tree Solution – https://lnkd.in/gyF9A5MU 🚀 Day 82 Completed! Enhanced my recursive thinking by learning how to track and update state efficiently during DFS traversal — a classic example of a Top-Down Recursive Approach that strengthens problem-solving in trees. 🌲💪 #Day82 #DSAChallenge #100DaysOfDSA #BinaryTrees #ProblemSolving #LeetCode #KeepGrinding #GrowthMindset #OpenToWork #MERNStack #FullStackDeveloper #JavaDeveloper #SoftwareEngineering #Hiring #Recruiters #1YOE

🚀Day 67 of #120_Days_LeetCode Challenge !! 🌳 Problem-Solving with Binary Trees: Constructing from Inorder & Postorder Traversals 🌳 Today, I worked on an interesting tree reconstruction problem where the goal was to build a binary tree from its inorder and postorder traversals. 🧩 Problem Statement: Given two integer arrays — inorder: the inorder traversal of a binary tree postorder: the postorder traversal of the same tree Reconstruct and return the binary tree. 💡 Key Insight: In postorder traversal, the last element is always the root of the tree. Using a hash map for quick index lookups in the inorder sequence helps efficiently locate the root position and divide the tree into left and right subtrees. ⚙️ Approach: Build a hash map to store inorder indices for O(1) lookups. Start from the end of the postorder array (root node). Recursively construct the right subtree first, then the left subtree, since postorder processes left → right → root. 🧠 Time Complexity: O(N) 📦 Space Complexity: O(N) (for recursion + hash map) 🔗 This problem sharpened my understanding of tree traversal relationships and recursion-based construction logic — a vital concept for many tree-based algorithms in interviews and real-world parsing systems. #Coding #DSA #BinaryTree #CPlusPlus #ProblemSolving #LeetCode #TechLearning #Algorithms #ProgrammingJourney

I’ve been consistently practicing Data Structures & Algorithms, focusing on understanding the underlying logic and core patterns behind each problem rather than just solving them. Here’s a summary of some recent problems I’ve tackled, along with the key concepts learned 📌 225. Implement Stack using Queues Key Concept: Queue-based simulation of stack operations (using two queues or a single optimized queue) https://lnkd.in/gabQrA_R 📌232. Implement Queue using Stacks Key Concept: Stack-based implementation using two stacks — one for enqueue, one for dequeue operations https://lnkd.in/gwq44Akm 📌102. Binary Tree Level Order Traversal Key Concept: Breadth-First Search (BFS) using a queue for level-wise traversal of binary trees https://lnkd.in/gn4ejwNK 📌239. Sliding Window Maximum Key Concept: Deque-based sliding window to efficiently track the maximum element in each window https://lnkd.in/gwDAFZkP 📌435. Non-overlapping Intervals Key Concept: Sorting by end time + greedy interval selection to minimize overlaps https://lnkd.in/gVwP-2pf 📌1710. Maximum Units on a Truck Key Concept: Greedy approach inspired by the knapsack problem — maximize total units by sorting on value https://lnkd.in/gqxdifBu 📌646. Maximum Length of Pair Chain Key Concept: Similar to non-overlapping intervals — greedy selection based on the smallest end time https://lnkd.in/gik6pJ6K These problems helped me strengthen concepts like queue–stack interconversion, BFS traversal, sliding window optimization, greedy algorithms, and interval scheduling techniques. I’d highly recommend trying these problems out — they’re great for building pattern recognition and problem-solving intuition. Here’s my LeetCode Profile for reference: https://lnkd.in/gp38YMN7 #DSA #LeetCode #Java #Algorithms #ProblemSolving #CodingInterview  #SoftwareDevelopment #SDE #TechJourney #DailyCoding