Merge Sorted Lists with Dummy Node Simplification

Right Side View: Last Node Per Level via BFS Right side view = rightmost node at each level. Use level-order traversal, collect all nodes per level, then take last valid node. That's the rightmost visible from right perspective. Level Pattern Variation: Standard BFS with twist — extract specific element (last) from each level. This "level + condition" pattern appears in zigzag traversal, vertical order, boundary problems. Time: O(n) | Space: O(w) #BFS #LevelOrder #RightSideView #TreeTraversal #Python #AlgorithmDesign #SoftwareEngineering

Add Two Numbers: Linked List Digit Addition with Carry Propagation Process lists simultaneously like grade-school addition. Handle different lengths by treating missing nodes as 0. Carry propagates to next iteration via loop condition carry > 0. Dummy node simplifies head handling. Continue until all lists exhausted AND carry is zero. Carry Handling: Including carry in loop condition ensures final carry digit gets added. Division/modulo elegantly extract carry and digit value. Time: O(max(m, n)) | Space: O(max(m, n)) #LinkedList #DigitAddition #CarryPropagation #SimulationAlgorithm #Python #AlgorithmDesign #SoftwareEngineering

Binary Tree Right Side View: Last Node Per Level via BFS Right side view = rightmost node at each level. Level-order traversal with twist — track last non-null node processed in each level. That's the rightmost visible node from right perspective. Level Pattern Variation: Standard level-order with tracking twist. Last valid node per level solves problem elegantly. This "level + condition" pattern appears in zigzag traversal, vertical order. Time: O(n) | Space: O(w) #BFS #LevelOrder #RightSideView #TreeTraversal #Python #AlgorithmDesign #SoftwareEngineering

Evaluate RPN: Stack for Postfix Expression Evaluation Postfix notation (Reverse Polish Notation) processes operators after operands. Stack naturally handles this — push numbers, on operator pop two operands, compute, push result. Final stack value is answer. No precedence handling needed unlike infix. Postfix Advantage: No parentheses or precedence rules needed. Stack evaluation is linear with simple logic. This makes RPN ideal for calculators and expression engines. Time: O(n) | Space: O(n) #Stack #RPN #ExpressionEvaluation #PostfixNotation #Python #AlgorithmDesign #SoftwareEngineering

Top K Frequent: Bucket Sort Beats Heap with O(n) Time Heap solution costs O(n log k). Bucket sort achieves O(n) by exploiting constraint — frequencies ≤ array length. Index represents frequency, value is list of elements with that frequency. Traverse high-to-low, collecting k elements. Bucket Sort Advantage: When value range is bounded (frequencies ≤ n), bucket sort beats comparison-based sorting. Exploiting constraints transforms complexity. Time: O(n) | Space: O(n) #BucketSort #TopK #FrequencyAnalysis #ComplexityReduction #Python #AlgorithmOptimization #SoftwareEngineering

LCA of BST: Exploiting Order Property for O(1) Space Generic tree LCA needs full traversal. BST ordering enables iterative solution — LCA is where paths diverge. Both values smaller? Go left. Both larger? Go right. Otherwise, current node is split point = LCA. BST Advantage: Ordering enables O(h) iterative solution without recursion stack. Divergence point is guaranteed LCA by BST property. This demonstrates how data structure properties simplify algorithms. Time: O(h) | Space: O(1) #BST #LCA #OrderProperty #IterativeSearch #Python #AlgorithmDesign #SoftwareEngineering

Just solved the classic Longest Substring Without Repeating Characters problem Used the sliding window + set approach to keep track of unique characters efficiently. Instead of restarting the search every time a duplicate appears, I shrink the window from the left until the substring becomes valid again. Key Idea: Maintain a dynamic window and adjust it in O(n) time. Complexity: Time: O(n) Space: O(n) Clean, efficient, and a great example of how powerful the sliding window technique can be! #Python #LeetCode #DataStructures #Algorithms #CodingJourney

Find Minimum in Rotated Sorted Array: Binary Search with Rotation Point Rotation breaks global sorting but one half is always properly sorted. Compare mid with right endpoint — if mid > right, minimum is in right half (rotation point there). Otherwise, minimum is in left half or at mid. Track minimum seen while narrowing. Rotation Point Detection: Comparing mid with endpoint (not left neighbor) determines which half contains rotation. This preserved partial ordering enables O(log n) despite global disruption. Time: O(log n) | Space: O(1) #BinarySearch #RotatedArray #MinimumFinding #RotationPoint #Python #AlgorithmDesign #SoftwareEngineering

Find Minimum in Rotated Array: Binary Search with Rotation Detection Rotation breaks global order but one half stays sorted. Compare mid with right endpoint — if mid > right, minimum is in right half (rotation there). Otherwise, minimum in left or at mid. Track minimum while narrowing. Rotation Point Detection: Comparing mid with endpoint determines which half contains rotation/minimum. This partial ordering enables O(log n) despite global disruption. Time: O(log n) | Space: O(1) #BinarySearch #RotatedArray #MinimumFinding #RotationPoint #Python #AlgorithmDesign #SoftwareEngineering

🗓 7 April 2026 Solved LeetCode Problem #73 — Set Matrix Zeroes Approach 💡 Used a simple and clean strategy with sets: • Traverse the matrix and store rows & columns containing 0 • In the next pass, set those entire rows and columns to 0 Why this works: We avoid modifying the matrix while scanning, preventing incorrect propagation of zeroes. Time Complexity ⏱: O(n × m) Space Complexity 📦: O(n + m) Learnings 📚 • Importance of separating observation and modification phases • Clean use of sets for tracking state • Trade-off between space and simplicity Next goal 🚀 Optimizing this to O(1) space using the first row & column as markers #leetcode #dsa #python #codingjourney #100daysofcode