DSA interview prep in Java and Python

The array-based patterns that show up constantly in interviews and in everyday backend code: two pointers, sliding windows, prefix sums, and in-place manipulation.

• Core Array Techniques

  • Array Traversal Basics
  • Two Pointers
  • Sliding Window
  • Prefix Sums
  • Kadane's Algorithm
  • In-Place Manipulation
  • Array Hashing
  • Sorting-Based Techniques
  • Single-Pass State Tracking
  • Lexicographic Rearrangement
  • Cyclic Sequence Detection
  • Counting via Merge Sort
  • Binary Exponentiation

• Matrix Techniques

  • Matrix In-Place Marking
  • Pascal's Triangle Construction
  • Matrix Rotation via Transpose
  • Grid Tabulation DP
  • Matrix Binary Search

Pointer-based traversal and rewiring — the data structure behind every "reverse", "merge", or "detect a cycle" interview question.

• Linked List Fundamentals

  • Singly Linked List Basics
  • Two-Pointer List Traversal
  • Linked List Merge Technique
  • Linked List Arithmetic
  • Linked List Intersection
  • Linked List Palindrome Check
  • Linked List Group Reversal
  • Linked List Flattening
  • Linked List Rotation
  • Linked List Deep Copy

Recursive traversal of hierarchical data, the pattern behind file systems, ASTs, and decision structures.

• Binary Tree Fundamentals

  • Binary Tree Traversal
  • Binary Tree DFS Traversal Orders
  • Morris Threaded Traversal
  • Single-Pass Triple Traversal
  • Binary Tree Height/Balance Check
  • Binary Tree LCA Search
  • Binary Tree Boundary Traversal
  • Binary Tree Mirror & Symmetry
  • Binary Tree Reconstruction
  • Flatten Binary Tree to Linked List
  • Binary Tree Children Sum Property
  • Binary Tree Serialize and Deserialize

• Binary Tree Views

  • Binary Tree Level View
  • Binary Tree Vertical Ordering
  • Binary Tree Level Linking

• Binary Search Tree Operations

  • BST Search and Insert
  • BST Construct From Preorder
  • LCA in a BST
  • BST Inorder Successor and Predecessor
  • BST Floor and Ceil
  • BST Kth Smallest and Largest
  • Two Sum in a BST
  • BST Iterator Design
  • Largest BST Subtree

Traversal (BFS/DFS) over arbitrary connections, the pattern behind dependency resolution, network reachability, and routing.

• Graph Traversal Fundamentals

  • Graph BFS/DFS
  • Flood-Fill Traversal
  • Graph Clone
  • Graph Cycle Detection
  • Topological Sort
  • Graph Bipartite Check

• Advanced Graph Algorithms

  • Strongly Connected Components (Kosaraju's)
  • Dijkstra's Algorithm
  • Bellman-Ford Algorithm
  • Floyd-Warshall Algorithm
  • Minimum Spanning Tree

Solving a problem by branching into smaller versions of itself, the backbone of combinatorial search.

• Recursion & Backtracking Fundamentals

  • Backtracking: Subsets & Choices
  • Backtracking Partition Enumeration
  • Kth Permutation by Factorial Counting
  • Constraint Satisfaction Backtracking
  • Grid Path Backtracking
  • Backtracking Permutation Generation

Turning exponential recursive branching into linear or polynomial time by reusing overlapping subproblem results.

• Dynamic Programming Fundamentals

  • DP: 1D Tabulation

• Classic DP Patterns

  • DP: Kadane's Variants
  • Longest Increasing Subsequence
  • Longest Common Subsequence
  • 0/1 Knapsack
  • Edit Distance
  • Matrix Chain Multiplication
  • Unbounded Knapsack Patterns
  • Subset Sum (Boolean DP)
  • Super Egg Drop
  • Word Break (DP)
  • Weighted Job Scheduling

Exploiting sorted order to search in logarithmic time instead of linear.

• Searching & Sorting Fundamentals

  • Binary Search Basics
  • Binary Search on Answer
  • Binary Search on Two Arrays

Solving problems with bitwise operators directly, often turning an O(n) space problem into O(1).

• Bit Manipulation Fundamentals

  • Bitwise Basics

Character-level array manipulation with its own common gotchas around comparison, mutability, and encoding.

• String Fundamentals

  • String Manipulation Basics
  • String Symbol Mapping
  • String Prefix Comparison
  • String Parsing State Machine
  • String Tokenization Reversal
  • String Repetition Search
  • Naive Substring Search
  • Run-Length Generation
  • String Segment Comparison
  • KMP Failure Function Application

Trading O(n) extra space for O(1) average-case lookup, the single highest-leverage technique in interview problem solving.

• Hashing Fundamentals

  • Hash Map Frequency Patterns
  • Sliding Window Distinct Count

Making the locally-best choice at each step and trusting it to produce a globally optimal result - and learning to recognize the (narrow) conditions under which that trust is actually justified.

• Greedy Fundamentals

  • Greedy Sorted Matching
  • Activity Selection Greedy
  • Fractional Knapsack Greedy
  • Deadline Scheduling Greedy
  • Greedy Denomination Coins
  • Interval Overlap Counting Greedy

A tree-shaped structure that keeps the minimum (or maximum) of a changing collection always at the root, in O(log n) per insert or removal - the standard tool for "keep track of the best/worst so far" and "process items in priority order" problems.

• Heap Fundamentals

  • Heap Kth-Element Selection
  • Heap Frequency Ranking
  • Two-Heap Median Maintenance
  • Heap Implementation From Scratch
  • K-Way Merge Heap
  • Heap Frontier Pair Search
  • Kth Largest Element in a Stream

Two of the simplest possible data structures - restricted to adding and removing only at specific ends - and the surprising number of problems (matching, monotonic scans, simulating one structure with the other) that fall out of that restriction.

• Stacks and Queues Fundamentals

  • Stack Matching Validation
  • Array-Backed Stack and Queue
  • Cross-Structure Simulation
  • Monotonic Stack Technique
  • Recursive Stack Manipulation
  • Auxiliary Stack Tracking
  • Multi-Source BFS
  • Monotonic Stack Area Computation
  • Monotonic Deque Window
  • Stack Elimination Search

A 26-way (or 2-way, for bits) branching tree that stores strings (or numbers' binary form) character by character, so that prefix-based lookups, counts, and maximization queries cost only the length of the string involved - independent of how many strings are stored.

• Trie Fundamentals

  • Trie Implementation
  • Trie Count and Erase
  • Trie Prefix Matching
  • Trie Distinct Substrings
  • Binary Trie Max XOR