Rotated Array Binary Search with Sorted Half Detection

Search Rotated Sorted Array: Binary Search with Sorted Half Detection Rotation breaks global order but one half is always properly sorted. Determine which half is sorted by comparing mid with endpoints. If target falls within sorted half's range, search there; otherwise search rotated half. Preserves O(log n). Partial Invariant: When global invariant breaks, find preserved local properties. Here, one half always maintains sorting despite rotation. Time: O(log n) | Space: O(1) #BinarySearch #RotatedArray #PartialInvariant #SearchOptimization #Python #AlgorithmDesign #SoftwareEngineering

Search 2D Matrix: Two Binary Searches for O(log m + log n) Treating matrix as flat array needs complex indexing. Cleaner: two sequential binary searches — first finds correct row (compare against first/last elements), second searches within that row. Exploits both sorted dimensions independently. Two-Phase Decomposition: Break 2D problem into sequential 1D searches when structure allows. Clearer than single-pass coordinate arithmetic. Time: O(log m + log n) | Space: O(1) #BinarySearch #2DMatrix #TwoPhaseSearch #SearchOptimization #Python #AlgorithmDesign #SoftwareEngineering

Search 2D Matrix: Two Binary Searches for O(log m + log n) Treating matrix as flat array requires index arithmetic. Cleaner approach: two binary searches — first finds row (compare against first/last elements), second searches within that row. Exploits both sorted dimensions independently. Two-Phase Search: Decompose 2D problem into sequential 1D searches when structure allows. Clearer logic than single pass with coordinate arithmetic. Time: O(log m + log n) | Space: O(1) #BinarySearch #2DMatrix #TwoPhaseSearch #SearchOptimization #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

✅ Day 28 of #DSAPrep > Problem: Rearrange Array Elements by Sign > Platform: LeetCode > Concept: Array / Two Pointers Solved this problem using a two-pointer approach to place positive and negative numbers alternately in a new array. > Key Idea: Create a result array of same size Use one pointer for positive index (0,2,4...) Use another pointer for negative index (1,3,5...) Traverse input array and place elements accordingly > Time Complexity: O(n) > Space Complexity: O(n) #DSAPrep #Algorithms #Python #Arrays #TwoPointers #ProblemSolving #CodingJourney

Day 248 of #365DaysOfCode Solved a problem involving mirror pairs and index distance minimization using a hashmap-based approach. For each element, computed its digit-reversed counterpart and tracked indices to identify valid mirror pairs. The minimum distance was updated by comparing current positions with previously stored indices. The solution runs in O(n · d) time, where d is the number of digits, and efficiently leverages hashing for constant-time lookups. Continuing to build intuition around number manipulation and indexing strategies. #365DaysOfCode #Day248 #DSA #LeetCode #Python #Algorithms #HashMap #ProblemSolving #Consistency

Binary Tree Level Order Traversal: Queue with Level Isolation BFS naturally traverses level-by-level. Key technique: snapshot queue length before processing current level. Process exactly that many nodes, collecting values into level list while enqueueing children for next iteration. This prevents mixing levels. Level Isolation: Pre-loop length snapshot prevents newly-added children from affecting current level's iteration count. This pattern enables clean level-by-level processing. Time: O(n) | Space: O(w) where w = max width #BFS #LevelOrderTraversal #QueuePattern #TreeAlgorithms #Python #AlgorithmDesign #SoftwareEngineering

Kth Smallest in BST: Iterative Inorder with Early Termination Inorder traversal of BST yields sorted order. Instead of building full sorted list, use iterative inorder with counter — return at kth visit. Early termination avoids processing entire tree when k is small. Early Exit Advantage: Iterative inorder with counter stops at k, avoiding O(n) space for full list. Best when k << n. Stack simulates recursion while enabling early termination. Time: O(h + k) | Space: O(h) #BST #InorderTraversal #EarlyTermination #IterativeSearch #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

Solved Kth Smallest Element in a BST today Used an iterative inorder traversal (DFS with stack) to efficiently find the answer without extra space for storing nodes. Key idea: 👉 Inorder traversal of a BST gives nodes in sorted order 👉 So the k-th visited node is the answer Instead of recursion, I used a stack to simulate traversal: Go left as much as possible Process node Move right Clean, efficient, and interview-friendly ✅ Time: O(H + k) Space: O(H) (stack) Consistent practice is making these patterns feel natural 🚀 #LeetCode #DataStructures #Algorithms #Python #CodingInterview