Data Structures & Algorithms

Why Data Structures and Algorithms Matter

Computational Thinking & Problem-Solving

Algorithms — Core Concepts

Measuring Algorithm Efficiency

Asymptotic Notation — Formalizing Algorithm Efficiency

Case Analysis & Cost Models

Problem Constraints & Algorithmic Trade-offs

Expressing Algorithms Clearly

What Is a Data Structure?

Why We Need Different Data Structures

Classification of Data Structures (High-Level View)

Primitive Data Structures — Conceptual Overview

Non-Primitive Data Structures (Conceptual Overview)

Linear Data Structures

Non-Linear Data Structures

Abstract Data Types (ADT) — The Missing Mental Model

Choosing the Right Data Structure (Decision Framework)

What Are Primitive Data Structures (Revisited, But Deeper)

Binary Representation & Number Systems (Essential)

Integer Data Types

Floating-Point Data Types

Character Data Types

Boolean Data Type

Primitive Operations & Cost Model

Limitations of Primitive Data Structures

Language-Level View of Primitives (Bridge Module)

What Is a String?

How Strings Are Represented (Conceptual View)

Basic String Operations & Their Cost Model

String Immutability & Its Implications

Common String Patterns & Problem-Solving Techniques

String Comparison, Ordering & Equality

Memory & Space Behavior of Strings (Conceptual)

Real-World Applications of Strings

Limitations of Strings as a Data Structure

Strings as a Gateway to Arrays

Substring Position Finder

Substring Position Finder

Maximum Symmetric Substring

Maximum Unique Substring Length

What Is an Array? — The Fundamental Collection

Array Memory Model & Contiguous Storage

Static vs Dynamic Arrays

Core Array Operations & Cost Model

Array Traversal Patterns

The Two-Pointer Technique

Sliding Window Technique

Common Array Patterns & Problem Types

Multi-Dimensional Arrays — Extending Arrays to Grids and Beyond

Array Limitations & Need for Linked Structures

Filter Array By Value

Filter Array By Value

In-Place Unique Elements

Pair Target Sum

Maximum Water Container

Optimal Contiguous Subarray Sum

Why Linked Lists? Limitations of Arrays

What Is a Linked List?

Singly Linked List — Structure & Intuition

Node-Based Thinking: Pointers and References

Core Linked List Operations & Cost Model

Traversal, Insertion, and Deletion Patterns

Doubly Linked Lists — Bidirectional Navigation

Circular Linked Lists

Two-Pointer Techniques for Linked Lists

Common Linked List Patterns & Problem Types

Linked Lists vs Arrays — When to Use Which

Combine Ordered Sequences

Combine Ordered Sequences

Linked List Center Node

Cyclic Chain Detection

Linked List Number Addition

What Is a Stack? Real-World Intuition

Stack as an Abstract Data Type (ADT)

Stack Operations & Interface

Array-Based Stack Implementation

Linked List-Based Stack Implementation

Implementation Trade-offs: Array vs Linked List

Common Stack Patterns & Problem Types

Parentheses Matching & Expression Problems

Monotonic Stacks — Advanced Pattern

Call Stack & Execution Contexts

Smallest Element Tracker Stack

Smallest Element Tracker Stack

Next Warmer Day Distance

Nested Bracket Scoring

What Is a Queue? Real-World Intuition

Queue as an Abstract Data Type (ADT)

Queue Operations & Interface

Array-Based Queue & Circular Queue Implementation

Linked List-Based Queue Implementation

Double-Ended Queue (Deque) — Flexible Two-End Access

Priority Queue — Conceptual Introduction

Common Queue Patterns & Problem Types

Sliding Window Maximum — Monotonic Deque

Stacks vs Queues — Comparison & Use Cases

What Is Recursion? Conceptual Foundation

The Anatomy of a Recursive Function

Base Cases & Recursive Cases

The Call Stack & Recursion Execution

Visualizing Recursion Trees

Recursion vs Iteration

Time & Space Complexity of Recursive Algorithms

Common Recursive Patterns

Tail Recursion & Optimization

When Recursion Goes Wrong

Recursive Problem-Solving Strategies

Binary Power Verification

Tree Root-to-Leaf Paths

The Limitation Problem — Why O(1) Access Matters

What Is Hashing? Core Intuition

Hash Functions: Properties & Design

Hash Tables — Structure & Mechanism

Collision Handling: Chaining

Collision Handling — Open Addressing

Load Factor & Rehashing

Hash Table Operations & Amortized Cost Model

Hash Sets vs Hash Maps

Common Hashing Patterns & Problem Types

When Hashing Fails — Pathological Cases & Alternatives

Anagram Clustering

Duplicate Linked List with Arbitrary Links

What Is a Tree? Definition & Terminology

Binary Trees — Structure & Representation

Recursive Tree Algorithms

Tree Construction & Serialization

Common Tree Patterns & Problem Types

N-ary Trees & General Tree Structures

Why Trees? Limitations of Linear Structures

Tree Properties — Height, Depth, Levels

Tree Traversals — Inorder, Preorder, Postorder

Level-Order Traversal — BFS on Trees

Layer-by-Layer Binary Tree Values

Layer-by-Layer Binary Tree Values

Aggregate Path Numbers in Binary Tree

Rightmost Level Nodes

What Is a Binary Search Tree (BST)?

The BST Property & Its Power

BST Search Operation

BST Insertion Operation

BST Deletion Operation — The Complete Guide

BST Time Complexity Analysis

The Balance Problem — Degenerate BSTs

Inorder Traversal & Sorted Output

Common BST Patterns & Problem Types

BST Variants & Extensions

Smallest Value Gap in Binary Search Tree

Smallest Value Gap in Binary Search Tree

BST Rank Finder

Why Balance Matters — Motivation

Height-Balanced Trees — Concept & Invariants

AVL Trees — Rotations & Balancing

Red-Black Trees — Conceptual Overview

2-3 Trees & B-Trees — Conceptual Introduction

Balanced Tree Operations & Guarantees

Self-Balancing Trees in Practice

When to Use Balanced Trees vs Hash Tables

Priority Queues Revisited — Now with Implementation

Complete Binary Trees — The Foundation of Array-Based Heaps

Array-Based Heap Implementation

Heap Operations — Insert & Extract

Heapify — Building a Heap Efficiently

Heap Time Complexity Analysis

Min-Heap vs Max-Heap

Common Heap Patterns & Problem Types

Top-K Problems & Heap Applications

Streaming Kth Highest Tracker

Streaming Kth Highest Tracker

Find Kth Ranked Element

Adjacent Character Separator

What Is a Heap? Structure & Properties

String Search Problems — Motivation for Tries

What Is a Trie? Structure & Intuition

Trie Node Representation

Trie Operations — Insert, Search, StartsWith

Trie Time & Space Complexity

Word Dictionary & Autocomplete Systems

Common Trie Patterns & Problem Types

Compressed Tries — Patricia/Radix Trees (Conceptual)

String Segmentation

Dictionary Sentence Formation

Why Graphs? Real-World Networks

What Is a Graph? Definition & Terminology

Graph Types — Directed, Undirected, Weighted

Graph Representation — Adjacency Matrix

Graph Representation — Adjacency List

Graph Representation Trade-offs

Graph Properties — Connectivity, Cycles, Degree

Trees as Special Graphs

Common Graph Modeling Patterns

Introduction to Graph Algorithms

Count Connected Landmasses

Deep Copy Network

Count Connected Landmasses

The Search Problem — Formalization

Linear Search — The Baseline Search Algorithm

Binary Search — Core Algorithm

Binary Search Variations & Edge Cases

Binary Search on Answer Space

Search in Rotated Arrays

Search Space Reduction Patterns

Ternary Search — Finding Extrema in Unimodal Functions

Interpolation Search — Intelligent Probing Based on Value Distribution

Searching in 2D Matrices

Sorted Array Position Finder

Sorted Array Position Finder

Rotated Array Search

Target Element Range

Why Sorting Matters

Sorting Problem Formalization & Stability

Bubble Sort — Understanding the Simplest Sorting Algorithm

Selection Sort — Intuition & Analysis

Insertion Sort — Intuition & Analysis

Merge Sort — Divide & Conquer Sorting

Quick Sort — Partition-Based Sorting

Heap Sort — Heap-Based Sorting

Counting Sort: Breaking the Comparison-Based Barrier

Radix Sort — Digit-Based Sorting

Sorting Algorithm Comparison & Selection

Sorting in Practice — Library Functions

Linked List Sort

Linked List Sort

What Is Divide and Conquer?

The D&C Pattern — Divide, Conquer, Combine

Recurrence Relations & Master Theorem

Merge Sort as Divide and Conquer — Deep Dive

Quick Sort as Divide and Conquer — Deep Dive

Binary Search as Divide and Conquer

Maximum Subarray — Divide & Conquer Approach

Matrix Multiplication & Strassen's Algorithm

Common Divide and Conquer Patterns

When to Apply Divide and Conquer

Combine Sorted Sequences

What Is a Greedy Algorithm?

The Greedy Choice Property — Foundation of Greedy Algorithms

Optimal Substructure for Greedy Algorithms

Proving Greedy Algorithm Correctness

Activity Selection Problem

Fractional Knapsack — When Greedy Achieves Optimality

Huffman Coding — Optimal Prefix Codes

Interval Scheduling Patterns

Common Greedy Patterns

When Greedy Fails vs When It Works

Circular Route Fuel Station

Circular Route Fuel Station

Destination Reachability

Minimum Hops to Destination

What Is Dynamic Programming?

Overlapping Subproblems — The Heart of Dynamic Programming

Optimal Substructure — The Foundation of Dynamic Programming

Memoization — Top-Down Dynamic Programming

Tabulation — Bottom-Up Dynamic Programming

1D DP Problems — Fibonacci & Climbing Stairs

2D Dynamic Programming — Grid Paths & Longest Common Subsequence

Knapsack Problems — Resource-Constrained Optimization

String DP — Edit Distance

State Design & Transition Functions

Space Optimization Techniques in Dynamic Programming

Common DP Patterns

Dynamic Programming Problem-Solving Framework

Staircase Ascent

Staircase Ascent

Minimum Expense Staircase Traversal

Maximum Non-Adjacent Selection

Grid Minimum Cost Traversal

String Transformation Cost

What Is Backtracking?

Backtracking vs Brute Force: Understanding the Distinction

The Backtracking Template — Choose, Explore, Unchoose

Subsets & Subsequences

Permutations & Combinations

N-Queens Problem — The Classic Backtracking Challenge

Sudoku Solver — Backtracking in Action

Constraint Satisfaction & Pruning

Common Backtracking Patterns

Backtracking Time Complexity Analysis

Generate All Arrangements

Generate All Arrangements

Target Sum Combinations

Palindrome Segmentation

Throne Arrangement

Graph Traversal Overview

Depth-First Search (DFS) — Algorithm & Applications

Breadth-First Search (BFS) — Algorithm & Applications

Connected Components — Graph Decomposition

Cycle Detection

Topological Sorting

Shortest Path — Unweighted Graphs (BFS)

Shortest Path — Dijkstra's Algorithm

Shortest Path — Bellman-Ford Algorithm

All-Pairs Shortest Path — Floyd-Warshall (Conceptual)

Choosing the Right Shortest Path Algorithm

Region Color Propagation

Region Color Propagation

Task Dependency Validator

Task Execution Order

Signal Propagation Time

Implement downstream impact across a drainage network

Track visited drainage assets while following downstream links

Minimum Spanning Trees — Understanding the Concept

Prim's Algorithm

Kruskal's Algorithm — Edge-Centric MST Construction

Union-Find (Disjoint Set Union) — The Connectivity Powerhouse

Strongly Connected Components — Deep Connectivity in Directed Graphs

Articulation Points & Bridges

Bipartite Graphs

Network Flow — Conceptual Introduction

Advanced Graph Patterns: Classical Problems & Computational Boundaries

Two-Set Graph Partition

Safe Destination Nodes

String Matching Problem Formalization

Naive Pattern Matching — The Fundamental Algorithm

KMP Algorithm — Failure Function & Matching

Rabin-Karp Algorithm — Rolling Hash

Z-Algorithm: Linear-Time Pattern Matching

String Hashing Techniques

Longest Common Subsequence (Revisited)

Longest Palindromic Substring

Suffix Arrays & Suffix Trees (Conceptual)

Common String Algorithm Patterns

Pattern Text Matching

Binary Representation Revisited — The Language of Low-Level Optimization

Bitwise Operators — AND, OR, XOR, NOT

Bit Shifting — Left & Right Shifts

Common Bit Manipulation Tricks

Checking, Setting, Clearing, Toggling Bits

Power of Two & Counting Bits

Bitmasks for Subset Representation

XOR Patterns — Finding Missing & Duplicate Numbers

Bit Manipulation Problem Types

When to Use Bit Manipulation

Unique Element Finder

Unique Element Finder

Binary One Counter

Range Bitwise Conjunction

Segment Trees — Range Queries

Segment Tree Construction & Operations

Lazy Propagation — Efficient Range Updates

Fenwick Trees — Binary Indexed Trees

Sparse Tables — Immutable Range Queries

LRU Cache — Design & Implementation

Skip Lists — Probabilistic Alternative to Balanced Trees

Bloom Filters — Probabilistic Set Membership

When to Use Advanced Data Structures

Completed deliveries still count against route capacity

Measure peak load instead of total pickups

The Problem-Solving Mindset

Identifying Problem Patterns

Pattern Recognition Framework

Constraint-Based Algorithm Selection

Edge Cases & Testing Strategies

Debugging Algorithmic Code

Optimization Techniques

Time Management in Technical Interviews

From Solution to Clean Code

Building Long-Term DSA Fluency

Rainfall Basin Accumulation

Overlapping annotations leave fragments in redacted output

Merge overlapping spans while leaving the renderer cursor unchanged

Repeated translation placeholders disappear during review

Count every occurrence of a translation placeholder