DSA in Python — Course Track

Learn to think like a computer scientist. This track takes you from raw memory all the way to dynamic programming, building genuine intuition at every step.

Why This Track Exists

Every time you use Google Maps, Spotify’s shuffle, or Instagram’s feed, data structures and algorithms are running underneath. The code that makes those products fast isn’t magic — it’s the same ideas you’ll learn here, applied with care.

This track is structured like a course with a deliberate progression:

1. Start with memory and arrays — understand how data actually lives in RAM before touching any abstraction.
2. Move to linear structures — linked lists and queues that flex where arrays are rigid.
3. Build recursion intuition — train your brain to think in sub-problems.
4. Master sorting — the proving ground for algorithmic thinking.
5. Climb to advanced territory — trees, graphs, heaps, hashing, and dynamic programming.

Each section answers three questions: What is the data layout? Which operations are cheap? What trade-off is being made?

Sections

• Introduction What is a data structure? What is an algorithm? Why do they power the modern world?

• Algorithm Analysis Big O notation, time vs space complexity, and how to reason about performance mathematically.

Arrays

The foundation of almost every other data structure. Understand arrays and you understand memory.

• Overview
• RAM — How your computer actually stores data at the byte level.
• Static Arrays — Fixed-size, blazing fast, and the basis for everything else.
• Dynamic Arrays — How Python lists grow themselves automatically.
• Stacks — Last in, first out — the secret behind undo buttons and function calls.
• Kadane’s Algorithm — Find the maximum-sum subarray in a single pass.
• Sliding Window — Fixed Size — Efficiently process every window of size k.
• Sliding Window — Variable Size — Expand and shrink a window to meet a condition.
• Two Pointers — Solve array problems with two indices moving toward each other.
• Prefix Sums — Answer range-sum queries in O(1) after O(n) setup.

Linked Lists

Flexible structures where elements can live anywhere in memory, connected by pointers.

• Overview
• Singly Linked Lists — Chains of nodes, each pointing forward.
• Doubly Linked Lists — Chains that can walk backwards too.
• Queues — First in, first out — how printers and task schedulers work.
• Fast and Slow Pointers — Detect cycles and find midpoints with two pointers at different speeds.

Recursion

The art of solving a problem by solving a smaller version of itself.

• Overview
• Factorial — The classic entry point into recursive thinking.
• Fibonacci Sequence — Where naive recursion meets its first performance wall.

Sorting

Rearranging data is the most studied problem in computer science — and for good reason.

• Overview
• Insertion Sort — Simple, intuitive, and surprisingly fast on small inputs.
• Merge Sort — Divide, conquer, and merge — reliably O(n log n).
• Quick Sort — The algorithm powering most real-world sort implementations.
• Bucket Sort — When you know something about your data, you can beat O(n log n).

Binary Search

Find anything in a sorted collection in O(log n) — eliminate half the possibilities each step.

• Overview
• Search Array
• Search Range

Trees

Hierarchical structures that power databases, file systems, and autocomplete.

• Overview
• Binary Tree — Each node has at most two children.
• Binary Search Tree — A sorted tree you can search in O(log n).
• BST Insert and Remove
• Depth-First Search — Explore a tree going deep before going wide.
• Breadth-First Search — Explore layer by layer, level by level.
• BST Sets and Maps — How Python’s set and dict are built.
• Trie — A tree for storing strings — the backbone of autocomplete.
• Union-Find — Track connected components with near-O(1) union and find.
• Segment Tree — Range queries and updates in O(log n).
• Iterative DFS — DFS without recursion using an explicit stack.

Backtracking

Explore every possibility systematically — and prune dead ends early.

• Overview
• Tree Maze — Navigate a maze by trying every path and retreating when stuck.
• Subsets — Generate every subset of a set systematically.
• Combinations — Choose k items from n — without repetition.
• Permutations — Every possible ordering of a set of elements.

Heap / Priority Queue

Always get the minimum (or maximum) element in O(log n). Used in Dijkstra’s and task scheduling.

• Overview
• Heap Properties
• Push and Pop
• Heapify — Build a heap from an array in O(n).
• Two Heaps — Use a min-heap and max-heap together to track medians in real time.

Hashing

The secret behind Python’s dict and set — O(1) average lookup via math.

• Overview
• Hash Usage — Using hash maps and sets to solve problems fast.
• Hash Implementation — How collision resolution actually works inside.

Graphs

The most general structure — social networks, maps, and the internet are all graphs.

• Overview
• Intro to Graphs — Nodes, edges, directed vs undirected.
• Matrix DFS
• Matrix BFS
• Adjacency List — The most efficient graph representation for sparse graphs.
• Dijkstra’s — Shortest path in a weighted graph using a priority queue.
• Prim’s — Build a minimum spanning tree greedily, edge by edge.
• Kruskal’s — Build an MST by sorting edges and avoiding cycles.
• Topological Sort — Order tasks so every dependency comes before the task that needs it.

Dynamic Programming

Solve complex problems by caching the results of overlapping sub-problems.

• Overview
• 1-Dimension DP — Single-variable state: climbing stairs, coin change.
• 2-Dimension DP — Grid problems and string comparisons.
• 0 / 1 Knapsack — Pick items with weights and values — each item used at most once.
• Unbounded Knapsack — Same as knapsack but items can be reused unlimited times.
• LCS — Find the longest sequence common to two strings.
• Palindromes — Detect and build palindromic substrings with DP.

Bit Manipulation

Use binary operations directly — the lowest level of computation, and often the fastest.

• Overview
• Bit Operations — AND, OR, XOR, shifts — and why they matter.

Introduction to Data Structures and Algorithms

The Two-Second Question

When you type a search query into Google, something remarkable happens. In under two seconds, Google’s servers sift through an index representing hundreds of billions of web pages and return exactly the results you were looking for — ranked by relevance, filtered for quality, personalised to you.

How is that physically possible?

The answer isn’t “more computers” or “faster hardware.” The answer is algorithms and data structures. The right choice of data structure turns a problem that would take centuries into one that takes milliseconds. That’s not an exaggeration — it’s mathematics.

This track teaches you those ideas from the ground up.

What Is a Data Structure?

A data structure is a way of organising data in memory so that certain operations are efficient.

The word “organising” is the key. The same collection of numbers can be arranged in dozens of different ways, and each arrangement makes some things fast and other things slow.

Think of it like a kitchen. You could throw all your ingredients into one giant bin — that’s “just a pile of data.” Or you could sort them into labelled shelves, refrigerated compartments, and spice racks. The ingredients are identical, but the organisation changes everything about how quickly you can cook.

graph TD
    DS["Data Structures"]

    DS --> Linear["Linear"]
    DS --> NonLinear["Non-Linear"]
    DS --> HashBased["Hash-Based"]

    Linear --> Array["Array\nFast index access\nO(1) read"]
    Linear --> LinkedList["Linked List\nFast insertion\nO(1) prepend"]
    Linear --> Stack["Stack\nLast in, first out\nUndo / call stack"]
    Linear --> Queue["Queue\nFirst in, first out\nPrinters / schedulers"]

    NonLinear --> Tree["Tree\nHierarchical\nFile systems / DOM"]
    NonLinear --> Graph["Graph\nArbitrary connections\nMaps / social networks"]
    NonLinear --> Heap["Heap\nAlways fast min/max\nPriority queues"]

    HashBased --> HashMap["Hash Map\nO(1) average lookup\nPython dict"]
    HashBased --> HashSet["Hash Set\nO(1) membership test\nPython set"]

    style DS fill:#EEEDFE,stroke:#534AB7,color:#3C3489
    style Linear fill:#E6F1FB,stroke:#185FA5,color:#0C447C
    style NonLinear fill:#E1F5EE,stroke:#0F6E56,color:#085041
    style HashBased fill:#FAEEDA,stroke:#854F0B,color:#633806

A data structure is not just a container — it’s a contract. Each one promises certain performance characteristics, and violating those promises (using the wrong structure for the job) can make your program thousands of times slower than it needs to be.

What Is an Algorithm?

An algorithm is a precise, step-by-step procedure for solving a problem.

The word comes from the name of 9th-century Persian mathematician Muhammad ibn Musa al-Khwarizmi, whose works introduced systematic methods for solving equations to the Western world.

Algorithms have three properties:

1. Correctness — it produces the right answer for every valid input.
2. Finiteness — it terminates in a finite number of steps.
3. Efficiency — it uses a reasonable amount of time and memory.

You already know algorithms intuitively. A recipe is an algorithm. The process of looking up a word in a paper dictionary (open to the middle, decide if your word comes before or after, repeat) is an algorithm — and a clever one. That’s binary search, and it finds any word in a 1,000-page dictionary in at most 10 steps.

Why Do They Matter?

Here’s a concrete example. Suppose you need to check whether a number appears in a list of one million numbers.

Approach 1: Check every number (linear search) At worst, check all 1,000,000 entries.

Approach 2: Sort the list first, then binary search Sort once (roughly 20,000,000 operations), then each search takes just 20 steps.

If you run 10,000 searches, approach 2 does 20,000,000 + 200,000 = 20.2 million operations. Approach 1 does 10,000,000,000 — ten billion. That’s a 500x difference in work, and it grows wider as the dataset grows.

import time

# Simulate a large dataset
data = list(range(1_000_000))  # [0, 1, 2, ..., 999999]
target = 999_983               # near the end — worst case for linear search

# Approach 1: Linear search — O(n)
start = time.time()
found_linear = False
for item in data:
    if item == target:
        found_linear = True
        break
linear_ms = (time.time() - start) * 1000

# Approach 2: Binary search — O(log n)
start = time.time()
lo, hi = 0, len(data) - 1
found_binary = False
steps = 0
while lo <= hi:
    steps += 1
    mid = (lo + hi) // 2
    if data[mid] == target:
        found_binary = True
        break
    elif data[mid] < target:
        lo = mid + 1
    else:
        hi = mid - 1
binary_ms = (time.time() - start) * 1000

print(f"Dataset size: {len(data):,} items")
print(f"Target: {target}")
print()
print(f"Linear search:  {linear_ms:.3f} ms  (scans up to every item)")
print(f"Binary search:  {binary_ms:.4f} ms  ({steps} steps total)")
print()
if binary_ms > 0:
    print(f"Binary search was ~{linear_ms / binary_ms:.0f}x faster")
print(f"Binary search checked {steps} items vs up to 1,000,000")

The Core Idea: Three Connected Concepts

Every topic in this track connects back to three questions:

graph LR
    ML["Memory Layout\nHow is data arranged\nin RAM?"]
    OC["Operation Cost\nWhich actions are\ncheap vs expensive?"]
    PP["Problem Patterns\nWhich structure fits\nthis problem?"]

    ML --> OC
    OC --> PP
    PP --> ML

    style ML fill:#E6F1FB,stroke:#185FA5,color:#0C447C
    style OC fill:#FAEEDA,stroke:#854F0B,color:#633806
    style PP fill:#E1F5EE,stroke:#0F6E56,color:#085041

• An array is fast because its elements sit in a contiguous block of memory. The CPU can jump directly to any element using arithmetic. That’s O(1) access.
• A linked list is flexible because its nodes can live anywhere in memory — you just follow the chain of pointers. That makes insertion O(1) but lookup O(n).
• Recursion is elegant because the call stack remembers suspended work for you, letting you express divide-and-conquer solutions naturally.
• Sorting changes the shape of later problems — a sorted array enables binary search, which enables a whole class of efficient solutions.

Understanding these connections is what separates someone who memorises solutions from someone who derives them.

What to Look for in Each Topic

As you work through this track, ask these four questions for every data structure you encounter:

Real-World Uses

You’ll see DSA in action everywhere once you know what to look for:

• Google Search — inverted index (a hash map from word to list of pages) + PageRank (graph algorithm)
• GPS navigation — Dijkstra’s shortest-path algorithm (graph + priority queue)
• Git version control — directed acyclic graph of commits
• Database indexes — B-trees (generalised binary search trees)
• Browser history / undo — stack
• Streaming video buffering — queue
• Autocomplete / spell check — trie (a specialised tree)
• Python’s dict and set — hash tables

How This Track Is Structured

graph TD
    A["Memory & Arrays\nThe foundation"] --> B["Linked Lists\nFlexible chains"]
    B --> C["Recursion\nThinking in sub-problems"]
    C --> D["Sorting\nThe proving ground"]
    D --> E["Binary Search\nEliminating possibilities"]
    E --> F["Trees\nHierarchical structure"]
    F --> G["Backtracking\nSystematic exploration"]
    G --> H["Heaps\nAlways-fast min/max"]
    H --> I["Hashing\nO(1) lookup"]
    I --> J["Graphs\nThe most general structure"]
    J --> K["Dynamic Programming\nCaching sub-problem results"]
    K --> L["Bit Manipulation\nThe lowest level"]

    style A fill:#E1F5EE,stroke:#0F6E56,color:#085041
    style L fill:#EEEDFE,stroke:#534AB7,color:#3C3489

Each section builds on the last. Skip ahead and some concepts will seem mysterious. Follow the order and everything will click into place.

Let’s start with the language we use to talk about performance: Algorithm Analysis.

Algorithm Analysis — Complete Tutorial

A guide to Time Complexity, Space Complexity, Big O Notation, and the Turing Machine memory model — with runnable examples and real-world context.

Table of Contents

1. What is Algorithm Analysis?
2. Time Complexity
   • 2.1 Big O Notation
   • 2.2 Common Time Complexities
   • 2.3 Best, Average, and Worst Case
   • 2.4 Timing It Yourself
3. Space Complexity
   • 3.1 Auxiliary Space
   • 3.2 The Turing Machine Model — DSPACE
   • 3.3 The Three-Tape Model
   • 3.4 Space Complexity Classes
4. Time vs Space Trade-offs
5. Quick Reference Cheat Sheet

1. What is Algorithm Analysis?

When you write code to solve a problem, two questions always follow:

• How fast does it run? → Time Complexity
• How much memory does it use? → Space Complexity

Algorithm Analysis is the discipline of answering both questions mathematically, so your answers hold regardless of the machine, the programming language, or the size of the input.

This matters enormously in practice. A web server handling a million requests per day cannot afford an algorithm that is 100x slower than it could be. A mobile app cannot afford one that uses 10x more memory than necessary. Good engineers understand these costs before the code ships.

graph TD
    A["Algorithm Analysis"]
    A --> B["Time Complexity\nHow many operations?"]
    A --> C["Space Complexity\nHow much memory?"]

    B --> B1["Big O Notation\nUpper bound on growth"]
    B --> B2["Best / Average / Worst Case\nWhich scenario to plan for?"]
    B --> B3["Common Classes\nO(1), O(log n), O(n), O(n²)..."]

    C --> C1["Auxiliary Space\nOnly the scratch space counts"]
    C --> C2["Turing Machine Model\nWhy we exclude input and output"]
    C --> C3["Input / Work / Output Tapes\nA mental model for classification"]
    C --> C4["Space Complexity Classes\nO(1), O(log n), O(n), O(n²)"]

    style A fill:#EEEDFE,stroke:#534AB7,color:#3C3489
    style B fill:#E6F1FB,stroke:#185FA5,color:#0C447C
    style C fill:#E1F5EE,stroke:#0F6E56,color:#085041

2. Time Complexity

Time complexity measures how the number of operations your algorithm performs scales as the input size n grows.

We never measure raw seconds — hardware varies. Instead we count operations, and express how that count scales. An algorithm that takes 1 second on your laptop might take 0.01 seconds on a server, but the ratio of work between two inputs will be the same on both machines. That ratio is what time complexity captures.

2.1 Big O Notation

Big O is a mathematical notation that describes the upper bound of an algorithm’s growth rate.

Formal definition:

f(n) = O(g(n)) means there exist constants c > 0 and n₀ such that f(n) ≤ c · g(n) for all n ≥ n₀.

In plain English: “after a certain input size, the function never grows faster than g(n) by more than a constant factor.”

Think of it like a speed limit. If a road has a 100 km/h limit, you might sometimes go 80, sometimes 95 — but you’re guaranteed never to exceed 100. Big O is the speed limit for your algorithm’s growth.

The three asymptotic notations:

In everyday engineering, O (Big O) is the one you will use 95% of the time. It’s a promise: “my algorithm will never do worse than this.”

Key rules for computing Big O:

1. Drop constants — O(3n) → O(n). Constants don’t describe growth behaviour.
2. Drop lower-order terms — O(n² + n) → O(n²). The dominant term wins at large n.
3. Nested loops multiply — a loop inside a loop is O(n × n) = O(n²).
4. Sequential steps add — two loops one after another is O(n + n) = O(n).

# Rule 3 — nested loops multiply → O(n²)
# For every i, we do n iterations of j.
# Total: n × n = n² operations.

n = 4
print("Nested loops (O(n²)):")
for i in range(n):
    for j in range(n):
        print(f"  ({i},{j})", end="")
    print()

print()

# Rule 4 — sequential loops add → O(n + n) = O(n)
# First loop does n operations. Second loop does n more.
# Total: 2n → O(n). The 2 is a constant and gets dropped.

print("Sequential loops (O(n)):")
print("First pass: ", end="")
for i in range(n):
    print(i, end=" ")
print()
print("Second pass:", end=" ")
for j in range(n):
    print(j, end=" ")
print()
print(f"\nNested: {n*n} operations  |  Sequential: {n+n} operations")

2.2 Common Time Complexities

From fastest to slowest growth:

graph LR
    A["O(1)\nConstant"] --> B["O(log n)\nLogarithmic"]
    B --> C["O(n)\nLinear"]
    C --> D["O(n log n)\nLinearithmic"]
    D --> E["O(n²)\nQuadratic"]
    E --> F["O(2ⁿ)\nExponential"]
    F --> G["O(n!)\nFactorial"]

    style A fill:#E1F5EE,stroke:#0F6E56,color:#085041
    style B fill:#E6F1FB,stroke:#185FA5,color:#0C447C
    style C fill:#EEEDFE,stroke:#534AB7,color:#3C3489
    style D fill:#FAEEDA,stroke:#854F0B,color:#633806
    style E fill:#FAECE7,stroke:#993C1D,color:#712B13
    style F fill:#FCEBEB,stroke:#A32D2D,color:#791F1F
    style G fill:#FBEAF0,stroke:#993556,color:#72243E

Growth at a glance — operations needed for n = 1,000:

Real-world examples for each class:

Code examples for each class:

# O(1) — constant: index into array
# The array could have 10 elements or 10 million — the work is the same.
def get_first(arr):
    return arr[0]

# O(log n) — logarithmic: binary search (iterative)
# Each step cuts the remaining search space in half.
# 1,000,000 items → at most 20 steps. 1,000,000,000 → at most 30.
def binary_search(arr, target):
    lo, hi = 0, len(arr) - 1
    steps = 0
    while lo <= hi:
        steps += 1
        mid = (lo + hi) // 2
        if arr[mid] == target:
            return mid, steps
        elif arr[mid] < target:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1, steps

# O(n) — linear: find maximum
# Must look at every element at least once.
def find_max(arr):
    max_val = arr[0]
    for x in arr:
        if x > max_val:
            max_val = x
    return max_val

# O(n²) — quadratic: check all pairs
# For each element, compare against every other element.
def has_duplicate(arr):
    n = len(arr)
    comparisons = 0
    for i in range(n):
        for j in range(i + 1, n):
            comparisons += 1
            if arr[i] == arr[j]:
                return True, comparisons
    return False, comparisons

# Demonstration
arr = list(range(1, 1001))   # [1, 2, 3, ..., 1000]

idx, steps = binary_search(arr, 731)
print(f"Binary search for 731 in 1000 items: found at index {idx} in {steps} steps")

maximum = find_max(arr)
print(f"Find max in 1000 items: {maximum} (required 1000 comparisons)")

small = [1, 3, 5, 7, 9]
found, comps = has_duplicate(small)
print(f"Duplicate check in {small}: {found}, took {comps} comparisons")
print(f"(n={len(small)}, n²={len(small)**2}, actual={comps})")

2.3 Best, Average, and Worst Case

The same algorithm can behave very differently depending on the input. We distinguish three scenarios:

graph TD
    subgraph "Linear Search in [3, 7, 2, 9, 4]"
        BC["Best Case — O(1)\nTarget is the first element\narr[0] = target → done immediately"]
        AC["Average Case — O(n)\nTarget is somewhere in the middle\nCheck ~half the array on average"]
        WC["Worst Case — O(n)\nTarget is last or not present\nMust check every element"]
    end

    style BC fill:#E1F5EE,stroke:#0F6E56,color:#085041
    style AC fill:#FAEEDA,stroke:#854F0B,color:#633806
    style WC fill:#FCEBEB,stroke:#A32D2D,color:#791F1F

Why worst case matters most:

In practice, engineers focus on the worst case because:

• It is a guarantee — the algorithm will never be slower than this.
• Users experience the worst case, not the average. If your app freezes for one user in a thousand, that user writes the one-star review.
• Systems must be designed to handle peak load, not average load.

def linear_search(arr, target):
    comparisons = 0
    for i, x in enumerate(arr):
        comparisons += 1
        if x == target:
            return i, comparisons
    return -1, comparisons

arr = [3, 7, 2, 9, 4, 6, 1, 8, 5, 0]

# Best case: target is first element
idx, comps = linear_search(arr, 3)
print(f"Best case  — target=3  (first):  found at {idx}, {comps} comparison")

# Average case: target is in the middle
idx, comps = linear_search(arr, 6)
print(f"Average    — target=6  (middle): found at {idx}, {comps} comparisons")

# Worst case: target is last, or not present
idx, comps = linear_search(arr, 0)
print(f"Worst case — target=0  (last):   found at {idx}, {comps} comparisons")

idx, comps = linear_search(arr, 99)
print(f"Worst case — target=99 (absent): found at {idx}, {comps} comparisons")

print(f"\nArray has {len(arr)} elements.")
print("Worst case always checks all of them.")

Quicksort — a dramatic example:

This is why good quicksort implementations use random pivot selection — to avoid accidentally hitting the worst case on already-sorted data.

2.4 Timing It Yourself

Abstract complexity classes become real when you measure them. Here’s how O(n) vs O(n²) actually behaves on your hardware:

import time

def measure(fn, n):
    start = time.time()
    fn(n)
    return (time.time() - start) * 1000  # milliseconds

# O(n) algorithm: sum of first n numbers
def linear(n):
    total = 0
    for i in range(n):
        total += i
    return total

# O(n²) algorithm: sum all pairs (i, j)
def quadratic(n):
    total = 0
    for i in range(n):
        for j in range(n):
            total += i + j
    return total

sizes = [100, 500, 1000, 2000]

print(f"{'n':>6} | {'O(n) ms':>10} | {'O(n²) ms':>10} | {'Ratio':>8}")
print("-" * 45)

prev_linear = None
prev_quad = None

for n in sizes:
    t_linear = measure(linear, n)
    t_quad = measure(quadratic, n)
    ratio = t_quad / t_linear if t_linear > 0 else float('inf')
    print(f"{n:>6} | {t_linear:>10.3f} | {t_quad:>10.3f} | {ratio:>7.1f}x")

print()
print("Notice: when n doubles, O(n) roughly doubles.")
print("When n doubles, O(n²) roughly quadruples.")
print("This gap widens forever as n grows.")

3. Space Complexity

Space complexity measures how much extra memory an algorithm needs as input size n grows.

The critical word is extra. This is also called auxiliary space — the scratch space your algorithm needs to do its work, beyond what it was given.

3.1 Auxiliary Space

Auxiliary space is the temporary or extra space used by the algorithm, not counting the input itself.

Total Space = Input Space + Auxiliary Space
                             ↑
                    This is what Space Complexity measures

Why exclude the input?

The input already exists before your algorithm runs. You didn’t create it. Penalising an algorithm for the size of data it was handed would be misleading — especially for algorithms that operate in sublinear space (needing less memory than the input itself).

3.2 The Turing Machine Model — DSPACE

The formal justification for excluding input and output comes from theoretical computer science. Here is the intuition without the heavy machinery.

Imagine a universal computing machine — not any specific laptop or server, but an abstract machine that captures the essence of computation. Alan Turing described exactly this in 1936: a machine with an infinitely long tape that reads and writes symbols, one cell at a time.

DSPACE is the formal measure of how much tape this machine uses to solve a given problem — specifically, how many tape cells it touches beyond the input and output.

The key insight: several important algorithms are sublinear in space — they use less memory than the size of their input. Binary search, for example, searches a million-item array using only three variables (lo, hi, mid). If you counted the array as part of the space, binary search would look like an O(n) algorithm. But it isn’t — the array was already there. The algorithm itself uses O(1) space.

To make this precise and fair, the Turing machine model separates the input, the working scratch space, and the output onto different tapes. Space complexity only counts the scratch (work) tape.

3.3 The Three-Tape Model

The multi-tape Turing machine uses three distinct tapes:

graph TD
    IT["INPUT TAPE\nRead-only — never write to it\nNOT counted in space complexity\n\nExample: arr = [17, 5, 9, 3, 1]"]
    WT["WORK TAPE\nRead and write freely\nTHIS IS what space complexity measures\n\nExample: right_max = 9, i = 2"]
    OT["OUTPUT TAPE\nWrite-only — never read from it\nNOT counted in space complexity\n\nExample: ans = [-1, 9, 9, 17, ...]"]

    IT -->|"algorithm reads input"| WT
    WT -->|"algorithm writes result"| OT

    style IT fill:#E6F1FB,stroke:#185FA5,color:#0C447C
    style WT fill:#FAEEDA,stroke:#854F0B,color:#633806
    style OT fill:#E1F5EE,stroke:#0F6E56,color:#085041

The kitchen analogy:

Space complexity only counts the bowls and tools — the scratch space you consumed while cooking. The ingredients and the finished dish don’t count.

Three-question test — apply in order:

1. Is this variable the input? → Input tape. Do not count it.
2. Is this variable what I return? → Output tape. Do not count it.
3. Did I create this myself just to help compute the answer? → Work tape. Count it.

3.4 Space Complexity Classes

O(1) — Constant Space

The work tape size never grows, regardless of input size. Only a fixed number of scalar variables are used.

Real-world example: Reading through a million log entries and counting how many contain the word “ERROR” — you only need one counter variable, regardless of file size.

def replace_elements(arr):
    """
    Replace each element with the maximum element to its right.
    Last element becomes -1.
    """
    n = len(arr)
    ans = [0] * n       # OUTPUT tape — not counted
    right_max = -1      # WORK tape — 1 integer
    i = n - 1           # WORK tape — 1 integer

    while i >= 0:
        ans[i] = right_max
        right_max = max(arr[i], right_max)
        i -= 1

    return ans

# Tape assignment:
# arr      → Input  → NOT counted
# ans      → Output → NOT counted
# right_max → Work   → counted (1 integer)
# i         → Work   → counted (1 integer)
#
# Space complexity: O(1) — two integers on the work tape, always.

data = [17, 5, 9, 3, 1]
result = replace_elements(data)
print(f"Input:  {data}")
print(f"Output: {result}")
print()
print("Work tape contents at any moment:")
print("  right_max = one integer")
print("  i         = one integer")
print("  Total: O(1) — constant, no matter how large the array")

O(log n) — Logarithmic Space

The work tape grows, but very slowly — proportional to the logarithm of n.

The most common cause: recursion. Every recursive call adds a stack frame to the call stack. The call stack is part of the work tape.

Real-world example: Git’s internal tree operations are recursive. When you run git log, Git walks a tree structure recursively. The call stack depth is logarithmic in the number of commits for a balanced tree.

# Recursive binary search — O(log n) space from the call stack
def binary_search_recursive(arr, target, lo, hi, depth=0):
    if lo > hi:
        return -1, depth
    mid = (lo + hi) // 2
    print(f"  Depth {depth}: checking arr[{mid}] = {arr[mid]}, range [{lo}..{hi}]")
    if arr[mid] == target:
        return mid, depth
    elif arr[mid] < target:
        return binary_search_recursive(arr, target, mid + 1, hi, depth + 1)
    else:
        return binary_search_recursive(arr, target, lo, mid - 1, depth + 1)

arr = list(range(0, 1000, 10))  # [0, 10, 20, ..., 990]
target = 730

print(f"Searching for {target} in array of {len(arr)} items:")
idx, max_depth = binary_search_recursive(arr, target, 0, len(arr) - 1)
print(f"\nFound at index {idx}, max recursion depth: {max_depth}")
print(f"Array size: {len(arr)}, log₂({len(arr)}) ≈ {len(arr).bit_length() - 1}")
print(f"Call stack grew to at most {max_depth + 1} frames deep — O(log n) space")

graph TD
    F1["Stack frame 1\nlo=0, hi=99, mid=49"]
    F2["Stack frame 2\nlo=50, hi=99, mid=74"]
    F3["Stack frame 3\nlo=50, hi=73, mid=62"]
    FN["... log₂(n) frames deep at most"]

    F1 --> F2 --> F3 --> FN

    style F1 fill:#FAEEDA,stroke:#854F0B,color:#633806
    style F2 fill:#FAEEDA,stroke:#854F0B,color:#633806
    style F3 fill:#FAEEDA,stroke:#854F0B,color:#633806
    style FN fill:#FAEEDA,stroke:#854F0B,color:#633806

Compare iterative vs recursive binary search:

Same algorithm, same logic — different space complexity purely because of how it is written.

O(n) — Linear Space

The work tape grows proportionally to the input.

Real-world example: A web browser’s history list. Every page you visit gets added. The memory used is proportional to the number of pages visited.

def count_frequencies(arr):
    """Build a frequency table — classic O(n) space."""
    freq = {}           # WORK tape: grows with n unique elements
    for x in arr:
        freq[x] = freq.get(x, 0) + 1
    return freq         # OUTPUT tape: not counted as work

def find_two_sum(arr, target):
    """
    Find two indices that sum to target.
    Uses a hash map (O(n) work space) to achieve O(n) time
    instead of the O(n²) brute-force approach.
    """
    seen = {}           # WORK tape: up to n entries
    for i, x in enumerate(arr):
        complement = target - x
        if complement in seen:
            return seen[complement], i
        seen[x] = i
    return None

# Example 1: frequency table
words = ["apple", "banana", "apple", "cherry", "banana", "apple"]
freq = count_frequencies(words)
print("Word frequencies:")
for word, count in sorted(freq.items()):
    print(f"  {word}: {count}")
print(f"Work tape (freq dict) holds {len(freq)} entries for {len(words)} words")

# Example 2: two-sum
print()
numbers = [2, 7, 11, 15, 1, 8]
target = 9
result = find_two_sum(numbers, target)
if result:
    i, j = result
    print(f"Two sum: {numbers[i]} + {numbers[j]} = {target}  (indices {i} and {j})")
print("The 'seen' hash map trades O(n) space for O(n) time vs O(n²) brute-force")

O(n²) — Quadratic Space

The work tape holds a 2D structure — typically an n×n matrix or grid. These appear frequently in dynamic programming.

Real-world example: Spell checkers and DNA sequence alignment use the edit distance algorithm. Two strings of length n require an n×n grid to compute their minimum edit distance.

def edit_distance(s, t):
    """
    Minimum number of insertions, deletions, or substitutions
    to turn string s into string t.

    Classic O(n²) space DP solution.
    """
    m, n = len(s), len(t)
    # WORK tape: (m+1) × (n+1) grid = O(m*n) ≈ O(n²)
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    # Base cases
    for i in range(m + 1):
        dp[i][0] = i   # delete all of s
    for j in range(n + 1):
        dp[0][j] = j   # insert all of t

    # Fill the grid
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s[i-1] == t[j-1]:
                dp[i][j] = dp[i-1][j-1]          # characters match, free
            else:
                dp[i][j] = 1 + min(
                    dp[i-1][j],     # delete from s
                    dp[i][j-1],     # insert into t
                    dp[i-1][j-1]    # substitute
                )
    return dp[m][n]

def edit_distance_optimized(s, t):
    """
    Same result, but O(n) space — only keep the previous row.
    """
    m, n = len(s), len(t)
    prev = list(range(n + 1))   # WORK tape: only one row at a time!
    for i in range(1, m + 1):
        curr = [i] + [0] * n
        for j in range(1, n + 1):
            if s[i-1] == t[j-1]:
                curr[j] = prev[j-1]
            else:
                curr[j] = 1 + min(prev[j], curr[j-1], prev[j-1])
        prev = curr
    return prev[n]

pairs = [
    ("kitten", "sitting"),
    ("sunday", "saturday"),
    ("python", "python"),
    ("abc", ""),
]

print(f"{'s':>10}  {'t':>10}  {'distance':>8}  {'optimized':>9}")
print("-" * 45)
for s, t in pairs:
    d1 = edit_distance(s, t)
    d2 = edit_distance_optimized(s, t)
    print(f"{s:>10}  {t:>10}  {d1:>8}  {d2:>9}")

print()
print("Both give identical results.")
print("Original: O(n²) space (full grid in memory)")
print("Optimized: O(n) space (two rows at a time)")
print("Same time complexity — O(n²) either way.")

The key optimization insight: Many O(n²) DP problems can be reduced to O(n) space by noticing you only ever need the previous row, not the entire grid. You trade readability for memory efficiency.

graph TD
    subgraph "O(n²) Work tape — full grid"
        M["n × n matrix\n\n[ 0, 1, 2, 3, ... ]\n[ 1, 0, 1, 2, ... ]\n[ 2, 1, 0, 1, ... ]\n[ 3, 2, 1, 0, ... ]\n  ...   ...   ...   "]
    end
    subgraph "O(n) Work tape — two rows only"
        R["prev = [0, 1, 2, 3, ...]\ncurr = [1, 0, 1, 2, ...]"]
    end
    M -->|"Space optimization\n(same answers)"| R

    style M fill:#FAECE7,stroke:#993C1D,color:#712B13
    style R fill:#E1F5EE,stroke:#0F6E56,color:#085041

4. Time vs Space Trade-offs

In the real world, time and space often trade against each other. You can frequently buy speed by using more memory, or save memory by doing more computation.

graph LR
    A["Problem"] --> B{"Trade-off decision"}
    B -->|"More memory available"| C["Cache results\nMemoization / DP tables\nFaster time, higher space"]
    B -->|"Memory is constrained"| D["Recompute as needed\nOptimized DP rows\nMore time, lower space"]

    style C fill:#E6F1FB,stroke:#185FA5,color:#0C447C
    style D fill:#E1F5EE,stroke:#0F6E56,color:#085041
    style B fill:#FAEEDA,stroke:#854F0B,color:#633806

Classic examples:

Fibonacci — the textbook progression:

import sys

# Version 1: Naive recursion
# Time: O(2ⁿ) — recalculates the same values over and over
# Space: O(n) — the call stack
def fib_naive(n):
    if n <= 1:
        return n
    return fib_naive(n - 1) + fib_naive(n - 2)

# Version 2: Memoized recursion
# Time: O(n) — each value computed exactly once
# Space: O(n) — the memo table + call stack
def fib_memo(n, memo=None):
    if memo is None:
        memo = {}
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fib_memo(n - 1, memo) + fib_memo(n - 2, memo)
    return memo[n]

# Version 3: Bottom-up DP table
# Time: O(n) — one pass
# Space: O(n) — the dp array
def fib_dp(n):
    if n <= 1:
        return n
    dp = [0] * (n + 1)
    dp[1] = 1
    for i in range(2, n + 1):
        dp[i] = dp[i - 1] + dp[i - 2]
    return dp[n]

# Version 4: Space-optimized
# Time: O(n) — one pass
# Space: O(1) — only two variables!
def fib_optimized(n):
    if n <= 1:
        return n
    a, b = 0, 1
    for _ in range(n - 1):
        a, b = b, a + b
    return b

# Compare results (not timing naive for large n — it's too slow)
print(f"{'n':>4} | {'memo':>12} | {'dp':>12} | {'optimized':>12}")
print("-" * 50)
for n in [5, 10, 20, 30]:
    print(f"{n:>4} | {fib_memo(n):>12} | {fib_dp(n):>12} | {fib_optimized(n):>12}")

print()
print("All four versions give identical answers.")
print("The difference is time and space efficiency:")
print("  fib_naive:     O(2ⁿ) time, O(n) space — unusable for n > 40")
print("  fib_memo:      O(n) time,   O(n) space — fast, uses a dict")
print("  fib_dp:        O(n) time,   O(n) space — fast, uses an array")
print("  fib_optimized: O(n) time,   O(1) space — fast, uses 2 variables")

Real-world decision: When you’re running a web server handling millions of requests, and each request needs the 10,000th Fibonacci number, you’d precompute it once and store it. That’s trading O(1) space for O(1) time per request — the ultimate win.

5. Quick Reference Cheat Sheet

Big O Complexity Ladder

graph TD
    C1["O(1) — Constant\nArray index, dict lookup, stack push/pop\nDoes NOT grow with input"]
    C2["O(log n) — Logarithmic\nBinary search, balanced BST lookup\nGrows 1 step per doubling of input"]
    C3["O(n) — Linear\nLinear scan, sum, min/max\nGrows proportionally with input"]
    C4["O(n log n) — Linearithmic\nMerge sort, heap sort, Timsort\nSlightly worse than linear"]
    C5["O(n²) — Quadratic\nNested loops, bubble sort, comparing all pairs\nDoubling input → 4× the work"]
    C6["O(2ⁿ) — Exponential\nAll subsets, naive recursion\nAdding 1 to input → doubles the work"]
    C7["O(n!) — Factorial\nAll permutations, brute-force TSP\nPractically impossible for n > 15"]

    C1 --> C2 --> C3 --> C4 --> C5 --> C6 --> C7

    style C1 fill:#E1F5EE,stroke:#0F6E56,color:#085041
    style C2 fill:#E6F1FB,stroke:#185FA5,color:#0C447C
    style C3 fill:#EEEDFE,stroke:#534AB7,color:#3C3489
    style C4 fill:#FAEEDA,stroke:#854F0B,color:#633806
    style C5 fill:#FAECE7,stroke:#993C1D,color:#712B13
    style C6 fill:#FCEBEB,stroke:#A32D2D,color:#791F1F
    style C7 fill:#FBEAF0,stroke:#993556,color:#72243E

Time Complexity Reference

Space Complexity Reference

The Three-Tape Test

Is this variable the INPUT?   → Input tape.  Don't count it.
Is this variable the OUTPUT?  → Output tape. Don't count it.
Did I CREATE it as a helper?  → Work tape.   COUNT IT. ← this is your space complexity

Big O Simplification Rules

Drop constants:            O(3n)       → O(n)
Drop lower-order terms:    O(n² + n)   → O(n²)
Nested loops multiply:     O(n) × O(n) = O(n²)
Sequential steps add:      O(n) + O(n) = O(n)
Recursion depth × work:    log n levels × O(n) work = O(n log n)

The One-Sentence Summary

A good algorithm does the minimum necessary work (time) using the minimum necessary memory (space) — and understanding Big O is how you prove it.

Topics covered: Big O Notation · Ω and Θ · Best/Average/Worst Case · Timing Experiments · Auxiliary Space · DSPACE / Turing Machine Model · Input/Work/Output Tapes · O(1) · O(log n) · O(n) · O(n²) · Time–Space Trade-offs · Fibonacci progression.

Arrays

Every list in every app you have ever used is backed by an array. Your Spotify playlist, your Instagram feed, the leaderboard in your favourite game — all arrays under the hood. Understanding arrays means understanding the foundation that almost every other data structure is built on top of.

What is an array?

An array is a collection of items stored one after another in memory — like a row of labelled boxes on a shelf. Each box holds one value and has a unique number called an index starting from 0.

flowchart LR
    I["my_list"] --> A

    subgraph A["Array in memory"]
        direction LR
        B0["index 0\n---\n 'Alice' "]
        B1["index 1\n---\n 'Bob' "]
        B2["index 2\n---\n 'Carol' "]
        B3["index 3\n---\n 'Dan' "]
    end

Because items sit side-by-side in memory, the computer can jump straight to any slot using simple arithmetic. That is why reading arr[2] is just as fast as reading arr[0] — it is always a single step, no matter how large the array is.

A quick taste

players = ["Alice", "Bob", "Carol", "Dan"]

# Read any element in O(1) — instant, no matter the size
print("First player:", players[0])
print("Last player: ", players[-1])

# Iterate over all elements in O(n)
print("\nFull roster:")
for i, name in enumerate(players):
    print(f"  Slot {i}: {name}")

What you will learn in this section

This section builds your understanding layer by layer:

Where arrays appear in the real world

• Social media feeds — posts stored in order, newest first
• Image pixels — a 1080p image is just an array of 2,073,600 colour values
• Audio samples — a 44 kHz audio track stores 44,000 numbers per second
• Undo history — every keystroke you type is pushed onto an array
• Game inventories — item slots are fixed-size arrays
• Spreadsheets — each row and column is an array of cells

The two flavours

Arrays come in two main varieties that this section explores in depth:

flowchart TD
    A["Arrays"] --> B["Static Arrays\n(fixed capacity)"]
    A --> C["Dynamic Arrays\n(auto-resize)"]
    B --> D["Great when size is known\nC arrays, pixel buffers"]
    C --> E["Great when size changes\nPython list, Java ArrayList"]

Start with RAM to understand why arrays are designed the way they are, then work through each chapter in order.

RAM

Before arrays make sense, memory needs to make sense. And once you understand memory, the clever design of arrays will feel completely obvious.

RAM is a giant hotel

Picture a huge hotel with millions of numbered rooms, side by side down an infinitely long corridor. Every room has a unique address (room number) printed on the door, and each room can hold exactly one small value (typically 1 byte).

Your program is a guest who has been given a key to a block of rooms. When it needs to store a number, it checks in to a room and remembers the address. When it needs the number back, it walks straight to that door — no searching, no asking at reception.

The crucial insight: the CPU can open any room in O(1) time because it knows every address in advance. It never has to wander down the hallway checking room numbers one by one.

flowchart LR
    CPU["CPU"]

    subgraph RAM["RAM (the hotel)"]
        direction LR
        R0["addr 1000\n---\n 42 "]
        R1["addr 1001\n---\n 07 "]
        R2["addr 1002\n---\n 19 "]
        R3["addr 1003\n---\n 88 "]
        R4["addr 1004\n---\n 55 "]
        R5["addr 1005\n---\n 03 "]
    end

    CPU -- "read addr 1002" --> R2
    CPU -- "write addr 1004" --> R4

How an array maps onto RAM

When you create an integer array, Python (or C, or any language) reserves a contiguous block of rooms — a stretch of addresses all in a row. Each element lives in the next room along.

flowchart LR
    subgraph ARR["scores = [10, 30, 50, 70]"]
        direction LR
        A0["index 0\n---\n 10 "]
        A1["index 1\n---\n 30 "]
        A2["index 2\n---\n 50 "]
        A3["index 3\n---\n 70 "]
    end

    subgraph MEM["RAM addresses (4 bytes each)"]
        direction LR
        M0["addr 2000\n---\n 10 "]
        M1["addr 2004\n---\n 30 "]
        M2["addr 2008\n---\n 50 "]
        M3["addr 2012\n---\n 70 "]
    end

    A0 --> M0
    A1 --> M1
    A2 --> M2
    A3 --> M3

The O(1) address formula

If the array starts at address base and each element occupies size bytes, then the address of element i is:

address(i) = base + i × size

For the example above with base = 2000 and size = 4:

One multiplication, one addition — and the CPU is standing at exactly the right room door. That is why array index access is O(1) no matter whether the array has 4 elements or 4 million.

Seeing memory addresses in Python

Python hides raw memory management, but you can still peek at the underlying address of any object using id(). The value returned is the memory address where that object lives.

# id() returns the memory address of an object in CPython
a = 42
b = "hello"
c = [1, 2, 3]

print(f"Address of integer 42   : {id(a)}")
print(f"Address of string hello : {id(b)}")
print(f"Address of list [1,2,3] : {id(c)}")

# List elements are stored contiguously in a backing array.
# We can also examine the id of individual element objects.
numbers = [100, 200, 300, 400]
print("\nElement addresses inside the list:")
for i, val in enumerate(numbers):
    print(f"  numbers[{i}] = {val}  →  id = {id(numbers[i])}")

Static Arrays

Imagine buying an egg carton at the supermarket. It holds exactly 12 eggs — no more, no less. You cannot squeeze a 13th egg in, and the carton does not shrink if you only buy 6. That is a static array: a fixed-capacity container where every slot has a reserved place in memory.

Static arrays are the simplest and most efficient array type. They are used everywhere performance is critical — pixel buffers in images, audio sample arrays, network packet buffers, and low-level game engines all rely on them.

Reading and traversal

Because elements live at predictable addresses, reading any element by index costs O(1) — it is a single arithmetic calculation regardless of array size.

Walking the whole array visits n elements, so that costs O(n).

# Think of this as a fixed 5-slot container
scores = [88, 72, 95, 61, 84]

# O(1) random access — instant, no matter the size
print("Third score:", scores[2])

# O(n) traversal — visits every element once
print("\nAll scores:")
for i in range(len(scores)):
    print(f"  slot {i}: {scores[i]}")

# Index out of range is the classic static-array mistake
try:
    print(scores[10])
except IndexError as e:
    print(f"\nError: {e}  <- static arrays have hard boundaries!")

Deleting from the middle

This is where static arrays get expensive. Memory must stay contiguous, so when you remove an element from the middle, every element to its right has to slide one slot to the left to close the gap.

flowchart TB
    subgraph Before["BEFORE  —  delete index 1 (value 30)"]
        direction LR
        B0["0\n---\n 10 "]
        B1["1\n---\n 30 "]
        B2["2\n---\n 50 "]
        B3["3\n---\n 70 "]
    end

    subgraph After["AFTER  —  shift left, zero out tail"]
        direction LR
        A0["0\n---\n 10 "]
        A1["1\n---\n 50 "]
        A2["2\n---\n 70 "]
        A3["3\n---\n  0 "]
    end

    Before --> After

In the worst case (deleting the first element) every element shifts, so this is O(n).

def remove_at(arr, index, length):
    """Remove element at `index` by shifting later elements left."""
    # Slide everything after `index` one position to the left
    for i in range(index + 1, length):
        arr[i - 1] = arr[i]
    # Zero out the vacated last slot
    arr[length - 1] = 0
    return length - 1


arr = [10, 30, 50, 70, 0]   # last slot is reserved padding
length = 4

print("Before:", arr[:length])
length = remove_at(arr, 1, length)   # remove 30
print("After: ", arr[:length])
print("Full backing array:", arr)    # see the zeroed tail

Inserting into the middle

The opposite problem: to make a gap at a chosen position, every element from that position onward has to slide one slot to the right before you can write the new value.

flowchart TB
    subgraph Before["BEFORE  —  insert 99 at index 1"]
        direction LR
        B0["0\n---\n 10 "]
        B1["1\n---\n 30 "]
        B2["2\n---\n 50 "]
        B3["3\n---\n  _ "]
    end

    subgraph Shift["SHIFT RIGHT  —  make room at index 1"]
        direction LR
        S0["0\n---\n 10 "]
        S1["1\n---\n  _ "]
        S2["2\n---\n 30 "]
        S3["3\n---\n 50 "]
    end

    subgraph After["AFTER  —  write 99 into the gap"]
        direction LR
        A0["0\n---\n 10 "]
        A1["1\n---\n 99 "]
        A2["2\n---\n 30 "]
        A3["3\n---\n 50 "]
    end

    Before --> Shift --> After

Inserting at the front is the worst case — every element moves — so this is also O(n).

def insert_at(arr, index, value, length, capacity):
    """Insert `value` at `index` by shifting later elements right."""
    if length == capacity:
        raise ValueError("Array is full — static arrays cannot grow!")

    # Slide everything from `index` onward one position to the right
    for i in range(length - 1, index - 1, -1):
        arr[i + 1] = arr[i]

    arr[index] = value
    return length + 1


arr = [10, 30, 50, 0]    # one spare slot at the end
length = 3
capacity = len(arr)

print("Before:", arr[:length])
length = insert_at(arr, 1, 99, length, capacity)   # insert 99 at index 1
print("After: ", arr[:length])

Timing: reads vs inserts

Run this to see the time difference between O(1) reads and O(n) inserts at scale.

import time

SIZE = 100_000
arr = list(range(SIZE))

# O(1) read — blazing fast
start = time.perf_counter()
for _ in range(10_000):
    _ = arr[SIZE // 2]
read_time = time.perf_counter() - start

# O(n) insert at front — much slower
start = time.perf_counter()
for _ in range(100):
    arr.insert(0, -1)   # Python list.insert is O(n) for middle/front
insert_time = time.perf_counter() - start

print(f"10,000 random reads  : {read_time*1000:.2f} ms")
print(f"   100 front inserts : {insert_time*1000:.2f} ms")
print(f"\nInserts were ~{insert_time/read_time * 100:.0f}x slower per operation")

Operation complexity summary

Real-world uses

• Image pixel buffers — a 1920x1080 image is a flat static array of 2,073,600 colour values. Random access to any pixel is O(1).
• Audio samples — a WAV file stores 44,100 integer samples per second. The playback engine reads them in order at high speed.
• Lookup tables — precomputed values like sine/cosine tables are stored in static arrays for O(1) retrieval.
• Ring buffers in networking — fixed-size arrays used to buffer incoming packets before they are processed.

Takeaway

Static arrays shine when you know the size upfront and need fast reads. They become painful when you need to insert or delete from anywhere other than the end. The next chapter shows how dynamic arrays solve the growth problem.

Dynamic Arrays

Imagine a magical backpack that starts small but silently doubles in size the moment it gets full. You never have to think about how big it is — you just keep throwing things in. That is exactly how a dynamic array works.

Dynamic arrays give you the fast O(1) index access of static arrays while also letting the collection grow automatically as you add items. Python’s list, JavaScript’s Array, and Java’s ArrayList are all dynamic arrays under the hood.

The core idea

A dynamic array maintains two numbers internally:

• length — how many elements you have actually stored
• capacity — how many slots the underlying memory block can hold

When length == capacity and you try to add another element, the array quietly allocates a bigger block (usually 2x the current capacity), copies everything over, and continues as if nothing happened.

flowchart LR
    subgraph S1["Step 1: capacity=2, length=2\n(FULL)"]
        direction LR
        A0["0\n---\n 5 "]
        A1["1\n---\n 6 "]
    end

    subgraph S2["Step 2: allocate new block\ncapacity=4"]
        direction LR
        B0["0\n---\n 5 "]
        B1["1\n---\n 6 "]
        B2["2\n---\n _ "]
        B3["3\n---\n _ "]
    end

    subgraph S3["Step 3: append 7\nlength=3"]
        direction LR
        C0["0\n---\n 5 "]
        C1["1\n---\n 6 "]
        C2["2\n---\n 7 "]
        C3["3\n---\n _ "]
    end

    S1 -- "resize!" --> S2 --> S3

Building a dynamic array from scratch

This implementation mirrors exactly what Python’s built-in list does behind the scenes:

class DynamicArray:
    def __init__(self):
        self.capacity = 2         # starting size of the backing store
        self.length = 0           # number of real elements
        self.arr = [0] * self.capacity

    def pushback(self, value):
        """Append a value. Resize first if the array is full."""
        if self.length == self.capacity:
            self._resize()
        self.arr[self.length] = value
        self.length += 1

    def popback(self):
        """Remove and return the last element."""
        if self.length == 0:
            raise IndexError("popback from empty array")
        value = self.arr[self.length - 1]
        self.arr[self.length - 1] = 0   # optional cleanup
        self.length -= 1
        return value

    def get(self, index):
        """O(1) read by index."""
        if index < 0 or index >= self.length:
            raise IndexError("index out of range")
        return self.arr[index]

    def _resize(self):
        """Double the capacity and copy all elements over."""
        self.capacity *= 2
        new_arr = [0] * self.capacity
        for i in range(self.length):
            new_arr[i] = self.arr[i]
        self.arr = new_arr
        print(f"  [resize] capacity doubled to {self.capacity}")

    def values(self):
        return self.arr[:self.length]

    def __repr__(self):
        return f"DynamicArray(values={self.values()}, length={self.length}, capacity={self.capacity})"


# Watch the resizes happen live
da = DynamicArray()
for v in [5, 6, 7, 8, 9, 10, 11, 12]:
    da.pushback(v)
    print(f"  appended {v:2d}  →  {da}")

The capacity doubling chain

Every time the array fills up, capacity doubles. The sequence is predictable:

flowchart LR
    C1["capacity\n1"] --> C2["capacity\n2"]
    C2 --> C4["capacity\n4"]
    C4 --> C8["capacity\n8"]
    C8 --> C16["capacity\n16"]
    C16 --> C32["capacity\n32"]

This geometric growth is the key to why appends stay cheap on average.

Why append is amortized O(1)

A resize copies n elements and costs O(n). But resizes are rare — they only happen at capacities 1, 2, 4, 8, 16, … So if you append n items total:

• The resize at capacity 1 copies 1 element
• The resize at capacity 2 copies 2 elements
• The resize at capacity 4 copies 4 elements
• …
• The final resize copies at most n elements

Total copy work: 1 + 2 + 4 + ... + n = 2n. Spread across n appends, each append costs 2n / n = 2 on average — O(1) amortized.

# Prove it: measure the average cost of appending n elements
import time

def bench_appends(n):
    start = time.perf_counter()
    lst = []
    for i in range(n):
        lst.append(i)
    elapsed = time.perf_counter() - start
    return elapsed

sizes = [10_000, 100_000, 1_000_000]
for n in sizes:
    t = bench_appends(n)
    per_append = t / n * 1_000_000   # microseconds
    print(f"n={n:>9,}  total={t*1000:.1f}ms  per_append={per_append:.4f}us")

print("\nPer-append time stays roughly constant as n grows: amortized O(1)!")

Watching Python list capacity grow

Python does not expose capacity directly, but the sys.getsizeof() trick lets you watch memory usage jump at the doubling points:

import sys

lst = []
prev_size = sys.getsizeof(lst)
print(f"elements={0:>3}  memory={prev_size} bytes")

for i in range(1, 33):
    lst.append(i)
    size = sys.getsizeof(lst)
    marker = "  <-- RESIZE" if size != prev_size else ""
    print(f"elements={i:>3}  memory={size} bytes{marker}")
    prev_size = size

Real-world dynamic arrays

Operation complexity summary

Takeaway

Dynamic arrays solve the biggest limitation of static arrays (fixed size) while keeping O(1) random access and O(1) amortized appends. The price is occasional O(n) resize events and some wasted capacity. For most applications, that trade-off is completely worth it — which is why almost every language uses them as the default list type.

Next up: Stacks, a clever restriction on dynamic arrays that turns out to be one of the most powerful tools in computer science.

Stacks

Picture a stack of pancakes fresh off the griddle. You always add the newest pancake on top, and you always eat from the top first. You would never pull a pancake from the middle or the bottom — the whole structure works because there is only one end you can touch.

That is a stack in computer science: a collection that allows additions and removals at one end only — the top.

The LIFO principle

Stack stands for Last In, First Out. Whatever you added most recently is the first thing you get back. This single constraint makes stacks surprisingly powerful.

flowchart TB
    subgraph Stack["The Stack"]
        direction TB
        TOP["TOP  <-- always interact here"]
        E4["pancake 4  (added last, eaten first)"]
        E3["pancake 3"]
        E2["pancake 2"]
        E1["pancake 1  (added first, eaten last)"]
        BOTTOM["BOTTOM"]
    end

    TOP --> E4 --> E3 --> E2 --> E1 --> BOTTOM

The three core operations

Every stack provides exactly three operations:

Push: adding to the top

flowchart LR
    subgraph Before["Before push(40)"]
        direction TB
        T1["top --> 30"]
        V2["20"]
        V1["10"]
    end

    subgraph After["After push(40)"]
        direction TB
        T2["top --> 40"]
        V3["30"]
        V2b["20"]
        V1b["10"]
    end

    Before -- "push(40)" --> After

Pop: removing from the top

flowchart LR
    subgraph Before["Before pop()"]
        direction TB
        T1["top --> 40"]
        V3["30"]
        V2["20"]
        V1["10"]
    end

    subgraph After["After pop()  returns 40"]
        direction TB
        T2["top --> 30"]
        V2b["20"]
        V1b["10"]
    end

    Before -- "pop() = 40" --> After

A complete Stack implementation

class Stack:
    def __init__(self):
        self._data = []   # dynamic array as the backing store

    def push(self, value):
        """Add value to the top of the stack. O(1) amortized."""
        self._data.append(value)

    def pop(self):
        """Remove and return the top value. O(1). Raises if empty."""
        if self.is_empty():
            raise IndexError("pop from an empty stack")
        return self._data.pop()

    def peek(self):
        """Return the top value without removing it. O(1). Raises if empty."""
        if self.is_empty():
            raise IndexError("peek at an empty stack")
        return self._data[-1]

    def is_empty(self):
        """Return True if the stack has no elements."""
        return len(self._data) == 0

    def size(self):
        """Return the number of elements in the stack."""
        return len(self._data)

    def __repr__(self):
        if self.is_empty():
            return "Stack([]  <-- top)"
        items = " | ".join(str(x) for x in self._data)
        return f"Stack([{items}]  <-- top)"


# --- Demo ---
s = Stack()

print("=== Pushing 10, 20, 30, 40 ===")
for v in [10, 20, 30, 40]:
    s.push(v)
    print(f"  push({v:2d})  -->  {s}")

print(f"\npeek() = {s.peek()}  (stack unchanged: {s})")

print("\n=== Popping everything ===")
while not s.is_empty():
    val = s.pop()
    print(f"  pop() = {val:2d}  -->  {s}")

print("\nAttempting pop on empty stack:")
try:
    s.pop()
except IndexError as e:
    print(f"  IndexError: {e}")

Real-world uses

Browser back button

Every time you navigate to a new page, the browser pushes the current URL onto a history stack. When you hit Back, it pops the top URL and navigates there.

class BrowserHistory:
    def __init__(self, start_page):
        self._back_stack = Stack()
        self._current = start_page

    def visit(self, url):
        """Navigate to a new page."""
        self._back_stack.push(self._current)
        self._current = url
        print(f"  Visited: {self._current}")

    def back(self):
        """Go back to the previous page."""
        if self._back_stack.is_empty():
            print("  No history to go back to!")
            return
        self._current = self._back_stack.pop()
        print(f"  Back to: {self._current}")

    def current(self):
        return self._current


class Stack:
    def __init__(self):
        self._data = []
    def push(self, v):
        self._data.append(v)
    def pop(self):
        if not self._data:
            raise IndexError("empty")
        return self._data.pop()
    def peek(self):
        return self._data[-1]
    def is_empty(self):
        return len(self._data) == 0


browser = BrowserHistory("google.com")
browser.visit("github.com")
browser.visit("docs.python.org")
browser.visit("stackoverflow.com")

print(f"\nCurrent page: {browser.current()}")
print()
browser.back()
browser.back()
print(f"\nCurrent page: {browser.current()}")

Undo and redo

Text editors push every action onto an undo stack. Ctrl+Z pops the last action and reverses it, pushing it onto a redo stack so Ctrl+Y can restore it.

class Stack:
    def __init__(self):
        self._data = []
    def push(self, v):
        self._data.append(v)
    def pop(self):
        if not self._data:
            return None
        return self._data.pop()
    def peek(self):
        return self._data[-1] if self._data else None
    def is_empty(self):
        return len(self._data) == 0
    def __repr__(self):
        return str(self._data)


class TextEditor:
    def __init__(self):
        self.text = ""
        self._undo_stack = Stack()
        self._redo_stack = Stack()

    def type(self, chars):
        self._undo_stack.push(self.text)   # save current state
        self._redo_stack = Stack()          # typing clears redo history
        self.text += chars
        print(f"  type({chars!r})  -->  {self.text!r}")

    def undo(self):
        prev = self._undo_stack.pop()
        if prev is None:
            print("  Nothing to undo!")
            return
        self._redo_stack.push(self.text)
        self.text = prev
        print(f"  undo()          -->  {self.text!r}")

    def redo(self):
        nxt = self._redo_stack.pop()
        if nxt is None:
            print("  Nothing to redo!")
            return
        self._undo_stack.push(self.text)
        self.text = nxt
        print(f"  redo()          -->  {self.text!r}")


ed = TextEditor()
ed.type("Hello")
ed.type(", ")
ed.type("world")
ed.type("!")
print()
ed.undo()
ed.undo()
print()
ed.redo()

Balanced parentheses checker

A classic stack interview problem: scan a string left to right, push every opening bracket, and pop when you see a closing bracket. If the stack is empty at the end, the brackets are balanced.

class Stack:
    def __init__(self):
        self._data = []
    def push(self, v):
        self._data.append(v)
    def pop(self):
        return self._data.pop() if self._data else None
    def is_empty(self):
        return len(self._data) == 0


def is_balanced(s):
    stack = Stack()
    matching = {')': '(', ']': '[', '}': '{'}

    for ch in s:
        if ch in '([{':
            stack.push(ch)
        elif ch in ')]}':
            if stack.is_empty() or stack.pop() != matching[ch]:
                return False

    return stack.is_empty()


tests = [
    "((1 + 2) * (3 + 4))",
    "{[()]}",
    "([)]",
    "(((",
    "",
]

for expr in tests:
    result = is_balanced(expr)
    icon = "OK" if result else "FAIL"
    print(f"  {icon}  {expr!r}")

Other places stacks appear

• Function call stack — every function call in every program pushes a frame, every return pops it. The “stack overflow” error literally means the call stack ran out of space.
• Depth-first search (DFS) — graph traversal uses a stack (explicitly or via recursion) to track the current path.
• Expression evaluation — compilers use stacks to evaluate arithmetic expressions and respect operator precedence.
• HTML/XML parsing — opening tags are pushed; closing tags must match the top of the stack.

Operation complexity summary

Takeaway

A stack is a dynamic array with a single rule: only touch the top. That constraint sounds limiting, but it perfectly models a huge class of real problems — anything with a “most recent first” or “undo last action” pattern. The call stack in your computer right now is a stack, and you have been using stacks every time you pressed Ctrl+Z or the browser back button.

Kadane’s Algorithm

Your stock trading app shows the best period to buy and sell. You glance at a chart of daily gains and losses and want to know: which consecutive stretch of days would have made you the most money? Behind that feature — and countless others — lives Kadane’s algorithm.

The Problem

Given an array of integers (positive and negative), find the contiguous subarray whose elements sum to the largest possible value.

Input:  [-2, 1, -3, 4, -1, 2, 1, -5, 4]
Output: 6   (subarray [4, -1, 2, 1])

Why Brute Force Is Too Slow

The obvious approach checks every possible subarray:

def max_subarray_brute(arr):
    n = len(arr)
    max_sum = float('-inf')
    best_start = best_end = 0

    for i in range(n):
        for j in range(i, n):
            current = sum(arr[i:j+1])
            if current > max_sum:
                max_sum = current
                best_start, best_end = i, j

    return max_sum, arr[best_start:best_end+1]

arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
result, subarray = max_subarray_brute(arr)
print(f"Max sum: {result}")
print(f"Subarray: {subarray}")

# Show why this gets expensive
import time
import random

for size in [100, 1000, 5000]:
    data = [random.randint(-10, 10) for _ in range(size)]
    start = time.time()
    max_subarray_brute(data)
    elapsed = (time.time() - start) * 1000
    print(f"n={size:5d}: {elapsed:.1f} ms")

With n = 5000 the brute force checks over 12 million subarrays. At n = 100 000 that becomes 5 billion. We need better.

Time complexity: O(n²) — two nested loops Space complexity: O(1)

The Key Insight

At each position i, you face exactly one decision:

Should the current element join the existing subarray, or should it start a fresh subarray of its own?

If the running sum so far is negative, it is dragging you down. Throw it away and start fresh from the current element.

current_sum = max(arr[i], current_sum + arr[i])
max_sum     = max(max_sum, current_sum)

That single comparison is the entire algorithm.

Tracing Through the Example

Here is how current_sum and max_sum evolve over [-2, 1, -3, 4, -1, 2, 1, -5, 4]:

flowchart LR
    A["i=0\nval=-2\ncur=-2\nmax=-2"] --> B["i=1\nval=1\ncur=1\nmax=1"]
    B --> C["i=2\nval=-3\ncur=-2\nmax=1"]
    C --> D["i=3\nval=4\ncur=4\nmax=4"]
    D --> E["i=4\nval=-1\ncur=3\nmax=4"]
    E --> F["i=5\nval=2\ncur=5\nmax=5"]
    F --> G["i=6\nval=1\ncur=6\nmax=6"]
    G --> H["i=7\nval=-5\ncur=1\nmax=6"]
    H --> I["i=8\nval=4\ncur=5\nmax=6"]

At index 3, current_sum would have been -2 + 4 = 2, but starting fresh at 4 is better, so current_sum resets to 4. From there it grows to 6 before the -5 drags it back down.

Clean Implementation

def kadane(arr):
    if not arr:
        return 0

    current_sum = arr[0]
    max_sum = arr[0]

    for i in range(1, len(arr)):
        # Either extend the current subarray or start fresh
        current_sum = max(arr[i], current_sum + arr[i])
        max_sum = max(max_sum, current_sum)

    return max_sum

# Basic test
arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
print(f"Max subarray sum: {kadane(arr)}")  # 6

# Edge cases
print(f"All negative: {kadane([-3, -1, -4, -1, -5])}")  # -1
print(f"Single element: {kadane([7])}")                  # 7
print(f"All positive: {kadane([1, 2, 3, 4])}")           # 10

Time complexity: O(n) — one pass Space complexity: O(1) — no extra storage

Step-by-Step Trace Version

Seeing the algorithm think helps it click:

def kadane_verbose(arr):
    print(f"{'i':>3}  {'val':>5}  {'cur_sum':>8}  {'max_sum':>8}  note")
    print("-" * 45)

    current_sum = arr[0]
    max_sum = arr[0]
    print(f"{'0':>3}  {arr[0]:>5}  {current_sum:>8}  {max_sum:>8}  (seed)")

    for i in range(1, len(arr)):
        extended = current_sum + arr[i]
        fresh    = arr[i]
        current_sum = max(fresh, extended)
        max_sum = max(max_sum, current_sum)

        note = "start fresh" if fresh > extended else "extend"
        print(f"{i:>3}  {arr[i]:>5}  {current_sum:>8}  {max_sum:>8}  {note}")

    return max_sum

arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
result = kadane_verbose(arr)
print(f"\nAnswer: {result}")

Finding the Actual Subarray (Not Just the Sum)

Often you need the subarray itself, not only its sum:

def kadane_with_indices(arr):
    if not arr:
        return 0, 0, 0

    current_sum = arr[0]
    max_sum = arr[0]

    start = end = 0          # best subarray found so far
    temp_start = 0           # start of current candidate

    for i in range(1, len(arr)):
        if arr[i] > current_sum + arr[i]:
            # Starting fresh is better
            current_sum = arr[i]
            temp_start = i
        else:
            current_sum = current_sum + arr[i]

        if current_sum > max_sum:
            max_sum = current_sum
            start = temp_start
            end = i

    return max_sum, start, end

arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
total, s, e = kadane_with_indices(arr)
print(f"Max sum:  {total}")
print(f"Indices:  [{s}, {e}]")
print(f"Subarray: {arr[s:e+1]}")

Edge Cases

def kadane(arr):
    if not arr:
        return 0
    current_sum = max_sum = arr[0]
    for x in arr[1:]:
        current_sum = max(x, current_sum + x)
        max_sum = max(max_sum, current_sum)
    return max_sum

# All negative — the "least bad" element wins
print(kadane([-5, -3, -8, -1, -4]))   # -1

# Single element
print(kadane([42]))                    # 42
print(kadane([-7]))                    # -7

# Zeros in the array
print(kadane([0, -1, 0, -2, 0]))      # 0

# Already optimal is entire array
print(kadane([1, 2, 3, 4, 5]))        # 15

Real-World Applications

Stock Profit Analysis

The classic framing: arr[i] is the price change on day i. The maximum subarray sum is the best possible profit from buying and selling exactly once.

def best_trade_window(daily_changes):
    """
    Find the buy day and sell day that maximise profit.
    daily_changes[i] = price[i+1] - price[i]
    """
    if not daily_changes:
        return 0, -1, -1

    current_sum = daily_changes[0]
    max_sum = daily_changes[0]
    temp_start = 0
    start = end = 0

    for i in range(1, len(daily_changes)):
        if daily_changes[i] > current_sum + daily_changes[i]:
            current_sum = daily_changes[i]
            temp_start = i
        else:
            current_sum += daily_changes[i]

        if current_sum > max_sum:
            max_sum = current_sum
            start = temp_start
            end = i

    buy_day  = start
    sell_day = end + 1          # sell at close of next day
    return max_sum, buy_day, sell_day

prices = [7, 1, 5, 3, 6, 4]
changes = [prices[i+1] - prices[i] for i in range(len(prices)-1)]
profit, buy, sell = best_trade_window(changes)
print(f"Prices:    {prices}")
print(f"Changes:   {changes}")
print(f"Buy day:   {buy}  (price={prices[buy]})")
print(f"Sell day:  {sell} (price={prices[sell]})")
print(f"Profit:    {profit}")

Signal Processing

In audio or sensor data, Kadane’s algorithm finds the segment with the highest cumulative signal strength — useful for detecting bursts of activity:

def find_peak_signal_window(signal):
    """Find the start and end of the strongest signal burst."""
    max_sum, start, end = float('-inf'), 0, 0
    current_sum = signal[0]
    temp_start = 0
    max_sum = current_sum

    for i in range(1, len(signal)):
        if signal[i] > current_sum + signal[i]:
            current_sum = signal[i]
            temp_start = i
        else:
            current_sum += signal[i]
        if current_sum > max_sum:
            max_sum = current_sum
            start = temp_start
            end = i

    return max_sum, start, end

# Simulated sensor readings (positive = above baseline, negative = below)
sensor = [-1, -2, 4, 6, -1, 3, -8, 2, 1]
strength, s, e = find_peak_signal_window(sensor)
print(f"Signal:        {sensor}")
print(f"Peak window:   indices {s}–{e}  →  {sensor[s:e+1]}")
print(f"Total strength: {strength}")

Complexity Summary

Kadane’s algorithm is a beautiful example of dynamic programming without a table: the only “state” you carry forward is two numbers — current_sum and max_sum.

Sliding Window — Fixed Size

Find the maximum sum of any 3 consecutive elements in an array. The naive way recomputes the sum from scratch for every window. The sliding window technique throws away just the leftmost element and adds the new rightmost one — turning O(n·k) into O(n).

The Core Idea

Imagine a physical window of width k sliding across an array. As it moves one step right:

• Add the element entering from the right
• Remove the element leaving from the left

The sum updates in O(1) per step.

arr = [2, 1, 5, 1, 3, 2],  k = 3

Window [2, 1, 5]  →  sum = 8
       [1, 5, 1]  →  sum = 8 - 2 + 1 = 7   (remove 2, add 1)
          [5, 1, 3]  →  sum = 7 - 1 + 3 = 9   (remove 1, add 3)
             [1, 3, 2]  →  sum = 9 - 5 + 2 = 6   (remove 5, add 2)

Visualising the Window

flowchart LR
    subgraph arr["Array: [2, 1, 5, 1, 3, 2]  k=3"]
        direction LR
        W1["Window 1\n[2, 1, 5]\nsum=8"]
        W2["Window 2\n[1, 5, 1]\nsum=7"]
        W3["Window 3\n[5, 1, 3]\nsum=9 ✓"]
        W4["Window 4\n[1, 3, 2]\nsum=6"]
        W1 -->|"−2 +1"| W2
        W2 -->|"−1 +3"| W3
        W3 -->|"−5 +2"| W4
    end

Problem 1 — Maximum Sum Subarray of Size k

def max_sum_subarray(arr, k):
    n = len(arr)
    if n < k:
        return None

    # Build the first window
    window_sum = sum(arr[:k])
    max_sum = window_sum

    # Slide: add right element, remove left element
    for i in range(k, n):
        window_sum += arr[i] - arr[i - k]
        if window_sum > max_sum:
            max_sum = window_sum

    return max_sum

arr = [2, 1, 5, 1, 3, 2]
print(f"Array: {arr}")
print(f"Max sum of size 3: {max_sum_subarray(arr, 3)}")   # 9

arr2 = [1, 4, 2, 9, 7, 3, 8, 2]
print(f"\nArray: {arr2}")
print(f"Max sum of size 4: {max_sum_subarray(arr2, 4)}")  # 27  (9+7+3+8)

Time: O(n) — one pass after the initial window setup Space: O(1) — only three variables

Trace version

def max_sum_trace(arr, k):
    n = len(arr)
    window_sum = sum(arr[:k])
    max_sum = window_sum
    best_start = 0

    print(f"Initial window {arr[:k]}: sum = {window_sum}")

    for i in range(k, n):
        removed = arr[i - k]
        added   = arr[i]
        window_sum += added - removed
        window_start = i - k + 1
        marker = " ← new max" if window_sum > max_sum else ""
        print(f"Remove {removed}, add {added}  →  {arr[window_start:i+1]}: sum = {window_sum}{marker}")
        if window_sum > max_sum:
            max_sum = window_sum
            best_start = window_start

    print(f"\nBest window: {arr[best_start:best_start+k]}, sum = {max_sum}")
    return max_sum

max_sum_trace([2, 1, 5, 1, 3, 2], k=3)

Problem 2 — Average of Every Window of Size k

def window_averages(arr, k):
    n = len(arr)
    if n < k:
        return []

    averages = []
    window_sum = sum(arr[:k])
    averages.append(round(window_sum / k, 2))

    for i in range(k, n):
        window_sum += arr[i] - arr[i - k]
        averages.append(round(window_sum / k, 2))

    return averages

# Daily temperatures over a week, k=3 day rolling average
temps = [22, 24, 21, 26, 28, 25, 27]
avgs  = window_averages(temps, k=3)

print("Day temperatures:", temps)
print("3-day rolling avg:", avgs)

# Show paired output
for i, avg in enumerate(avgs):
    window = temps[i:i+3]
    print(f"  Days {i+1}–{i+3}: {window}  →  avg {avg}°C")

Problem 3 — First Negative Number in Every Window of Size k

def first_negative_in_windows(arr, k):
    """
    For each window of size k, report the first negative number.
    Report 0 if the window has no negatives.
    Uses a deque to track indices of negative numbers.
    """
    from collections import deque

    n = len(arr)
    result = []
    neg_indices = deque()   # stores indices of negatives in current window

    for i in range(n):
        # Add current element if it is negative
        if arr[i] < 0:
            neg_indices.append(i)

        # Remove indices that have slid out of the window
        if neg_indices and neg_indices[0] < i - k + 1:
            neg_indices.popleft()

        # Record result once the first full window is formed
        if i >= k - 1:
            result.append(arr[neg_indices[0]] if neg_indices else 0)

    return result

arr = [-3, -1, 2, -4, 5, 3, -2]
k = 3
results = first_negative_in_windows(arr, k)

print(f"Array: {arr},  k = {k}\n")
for i, first_neg in enumerate(results):
    window = arr[i:i+k]
    msg = first_neg if first_neg != 0 else "none"
    print(f"Window {window}: first negative = {msg}")

Comparing All Three in One Run

def sliding_window_summary(arr, k):
    from collections import deque

    n = len(arr)
    max_sum = float('-inf')
    window_sum = sum(arr[:k])
    current_sum = window_sum
    neg_indices = deque()

    for j in range(k):
        if arr[j] < 0:
            neg_indices.append(j)

    averages = [round(window_sum / k, 2)]
    max_sum = window_sum
    firsts  = []

    if neg_indices:
        firsts.append(arr[neg_indices[0]])
    else:
        firsts.append(0)

    for i in range(k, n):
        window_sum += arr[i] - arr[i - k]
        if arr[i] < 0:
            neg_indices.append(i)
        if neg_indices and neg_indices[0] < i - k + 1:
            neg_indices.popleft()

        averages.append(round(window_sum / k, 2))
        max_sum = max(max_sum, window_sum)
        firsts.append(arr[neg_indices[0]] if neg_indices else 0)

    print(f"Array: {arr},  k = {k}")
    print(f"Max sum of any window:     {max_sum}")
    print(f"Window averages:           {averages}")
    print(f"First negative per window: {firsts}")

sliding_window_summary([2, -1, 5, 1, -3, 2], k=3)

Real-World Applications

Moving Average in Finance

Financial dashboards smooth noisy price data with a rolling average. A 20-day or 50-day moving average is computed exactly like Problem 2 above — slide a fixed-size window over daily closing prices.

def moving_average(prices, window=5):
    avgs = []
    total = sum(prices[:window])
    avgs.append(total / window)
    for i in range(window, len(prices)):
        total += prices[i] - prices[i - window]
        avgs.append(round(total / window, 2))
    return avgs

# Mock closing prices for 10 days
prices = [150, 152, 149, 153, 158, 155, 160, 162, 157, 165]
ma5 = moving_average(prices, window=5)
print("Prices:        ", prices)
print("5-day MA:      ", ma5)

Network Throughput Monitoring

A network monitor tracks bytes received per second. A sliding window gives the average throughput over the last k seconds, smoothing out momentary spikes.

def throughput_monitor(bytes_per_second, window_secs=3):
    """Return max observed throughput and rolling average."""
    avg = moving_average(bytes_per_second, window=window_secs)
    peak = max(avg)
    return avg, peak

def moving_average(data, window):
    avgs = []
    total = sum(data[:window])
    avgs.append(round(total / window, 1))
    for i in range(window, len(data)):
        total += data[i] - data[i - window]
        avgs.append(round(total / window, 1))
    return avgs

# MB/s sampled every second over 10 seconds
samples = [12, 15, 14, 20, 35, 30, 10, 8, 9, 11]
avgs, peak = throughput_monitor(samples, window_secs=3)

print("Raw MB/s:      ", samples)
print("3-sec rolling: ", avgs)
print(f"Peak 3-sec avg: {peak} MB/s")

Complexity Summary

The fixed-size sliding window is one of the easiest ways to cut an O(n·k) solution down to O(n) — and once you see it, you will recognise it everywhere.

Sliding Window — Variable Size

Find the smallest subarray with a sum ≥ 7. Unlike the fixed-size window, this window has no fixed width — it grows when you need more and shrinks when you have enough. Two pointers (left and right) mark its boundaries, and together they do the job in O(n).

The Core Idea

Use two pointers, both starting at index 0:

1. Expand right — move right forward to grow the window and add more to the sum.
2. Shrink left — once the window satisfies the condition, try to make it smaller by moving left forward.
3. Record the best answer whenever the condition is satisfied.

Each pointer moves at most n steps, so the total work is O(n) even though it looks like two nested operations.

arr = [2, 3, 1, 2, 4, 3],  target = 7

left=0, right grows until sum ≥ 7:
  [2, 3, 1, 2]  sum=8 ≥ 7  →  length 4, try shrinking
  [3, 1, 2]     sum=6 < 7  →  can't shrink, expand again
  [3, 1, 2, 4]  sum=10 ≥ 7 →  length 4, try shrinking
  [1, 2, 4]     sum=7 ≥ 7  →  length 3, try shrinking
  [2, 4]        sum=6 < 7  →  can't shrink
  ...
Answer: 2  (subarray [4, 3])

Visualising Expand and Shrink

flowchart TD
    Start["left=0, right=0\nwindow_sum=0\nmin_len=∞"] --> Expand

    Expand["Expand: right++\nadd arr[right] to sum"] --> Check

    Check{"sum ≥ target?"}

    Check -->|No| Expand
    Check -->|Yes| Record["Record window length\nif smaller than min_len"]

    Record --> Shrink["Shrink: subtract arr[left]\nleft++"]

    Shrink --> StillOK{"sum still ≥ target?"}
    StillOK -->|Yes| Record
    StillOK -->|No| Done{"right at end?"}

    Done -->|No| Expand
    Done -->|Yes| Answer["Return min_len"]

Problem 1 — Smallest Subarray with Sum ≥ Target

def min_subarray_len(arr, target):
    left = 0
    window_sum = 0
    min_len = float('inf')

    for right in range(len(arr)):
        window_sum += arr[right]            # expand

        while window_sum >= target:         # shrink while valid
            min_len = min(min_len, right - left + 1)
            window_sum -= arr[left]
            left += 1

    return min_len if min_len != float('inf') else 0

arr = [2, 3, 1, 2, 4, 3]
print(f"Array: {arr},  target = 7")
print(f"Smallest length: {min_subarray_len(arr, 7)}")   # 2  ([4,3])

arr2 = [1, 1, 1, 1, 1, 1, 1]
print(f"\nArray: {arr2},  target = 11")
print(f"Smallest length: {min_subarray_len(arr2, 11)}")  # 0 (impossible)

Time: O(n) — left and right each travel the array once Space: O(1)

Trace version

def min_subarray_trace(arr, target):
    left = 0
    window_sum = 0
    min_len = float('inf')
    best = None

    print(f"Target = {target}\n")

    for right in range(len(arr)):
        window_sum += arr[right]
        print(f"Expand  right={right} (+{arr[right]})  window={arr[left:right+1]}  sum={window_sum}")

        while window_sum >= target:
            length = right - left + 1
            if length < min_len:
                min_len = length
                best = arr[left:right+1][:]
            print(f"  Shrink left={left} (−{arr[left]})  len={length} ← {'new best!' if length == min_len else ''}")
            window_sum -= arr[left]
            left += 1

    print(f"\nSmallest subarray: {best},  length = {min_len}")
    return min_len

min_subarray_trace([2, 3, 1, 2, 4, 3], target=7)

Problem 2 — Longest Substring Without Repeating Characters

The window now tracks characters instead of a numeric sum. We use a set to know what is currently inside the window.

def longest_unique_substring(s):
    char_set = set()
    left = 0
    max_len = 0
    best_start = 0

    for right in range(len(s)):
        # Shrink until the duplicate is gone
        while s[right] in char_set:
            char_set.remove(s[left])
            left += 1

        char_set.add(s[right])

        if right - left + 1 > max_len:
            max_len = right - left + 1
            best_start = left

    return max_len, s[best_start:best_start + max_len]

tests = ["abcabcbb", "bbbbb", "pwwkew", "dvdf", ""]
for t in tests:
    length, substr = longest_unique_substring(t)
    print(f'"{t}"  →  length={length}  window="{substr}"')

Trace to see the window in action

def longest_unique_trace(s):
    char_set = set()
    left = 0
    max_len = 0

    for right in range(len(s)):
        while s[right] in char_set:
            print(f"  Shrink: remove '{s[left]}'")
            char_set.remove(s[left])
            left += 1

        char_set.add(s[right])
        current = s[left:right+1]
        new_best = " ← new best" if len(current) > max_len else ""
        print(f"Add '{s[right]}'  window='{current}'{new_best}")
        max_len = max(max_len, len(current))

    print(f"\nMax length: {max_len}")

longest_unique_trace("abcabcbb")

Problem 3 — Longest Subarray with at Most k Distinct Characters

Generalise: allow at most k different characters. Use a dictionary to count each character’s frequency in the window.

def longest_k_distinct(s, k):
    from collections import defaultdict

    char_count = defaultdict(int)
    left = 0
    max_len = 0
    best_start = 0

    for right in range(len(s)):
        char_count[s[right]] += 1

        # Too many distinct chars — shrink
        while len(char_count) > k:
            char_count[s[left]] -= 1
            if char_count[s[left]] == 0:
                del char_count[s[left]]
            left += 1

        if right - left + 1 > max_len:
            max_len = right - left + 1
            best_start = left

    return max_len, s[best_start:best_start + max_len]

tests = [
    ("eceba",   2),
    ("aa",      1),
    ("aabbcc",  2),
    ("aabbcc",  3),
]
for s, k in tests:
    length, substr = longest_k_distinct(s, k)
    print(f'"{s}"  k={k}  →  length={length}  "{substr}"')

Comparing Variable vs Fixed Windows

def demo_both():
    arr = [2, 3, 1, 2, 4, 3]

    # Fixed: max sum of exactly k=3 elements
    k = 3
    window_sum = sum(arr[:k])
    max_sum = window_sum
    for i in range(k, len(arr)):
        window_sum += arr[i] - arr[i - k]
        max_sum = max(max_sum, window_sum)
    print(f"Fixed k={k}: max sum = {max_sum}")

    # Variable: smallest subarray with sum >= 7
    left = window_sum_v = 0
    min_len = float('inf')
    for right in range(len(arr)):
        window_sum_v += arr[right]
        while window_sum_v >= 7:
            min_len = min(min_len, right - left + 1)
            window_sum_v -= arr[left]
            left += 1
    print(f"Variable target=7: min length = {min_len}")

demo_both()

Real-World Applications

Network Rate Limiting

A rate limiter allows at most N requests in any rolling window. As new requests arrive, the window grows; as old ones expire, it shrinks. Variable window size is the natural fit.

def max_requests_in_window(timestamps_ms, window_ms):
    """
    Find the maximum number of requests in any window of duration window_ms.
    timestamps_ms: sorted list of request arrival times in milliseconds.
    """
    left = 0
    max_count = 0

    for right in range(len(timestamps_ms)):
        # Shrink while window exceeds allowed duration
        while timestamps_ms[right] - timestamps_ms[left] > window_ms:
            left += 1
        max_count = max(max_count, right - left + 1)

    return max_count

# Request timestamps (ms since start)
requests = [0, 100, 200, 300, 350, 400, 900, 1000]
window   = 500   # 500 ms rolling window

peak = max_requests_in_window(requests, window)
print(f"Timestamps (ms): {requests}")
print(f"Window size:     {window} ms")
print(f"Peak requests:   {peak}")

Longest User Session Without Logout

Given a log of page-view events, find the longest streak of activity where the user never went idle for more than gap seconds.

def longest_active_session(event_times, max_gap):
    """
    Find the length of the longest session where no gap between
    consecutive events exceeds max_gap seconds.
    """
    if not event_times:
        return 0

    left = 0
    max_events = 1

    for right in range(1, len(event_times)):
        # A gap larger than allowed breaks the session
        if event_times[right] - event_times[right - 1] > max_gap:
            left = right   # start a new session

        max_events = max(max_events, right - left + 1)

    return max_events

# Event timestamps in seconds
events  = [0, 10, 25, 30, 80, 85, 90, 200, 210, 215, 220]
max_gap = 60   # seconds

length = longest_active_session(events, max_gap)
print(f"Events (s): {events}")
print(f"Max gap:    {max_gap}s")
print(f"Longest session: {length} events")

Complexity Summary

The variable sliding window is powerful because the same two-pointer skeleton solves wildly different problems — just change what “condition met” means.

Two Pointers

Two detectives searching a sorted list from opposite ends — one starting at the smallest value, one at the largest. They compare, decide who moves inward, and meet in the middle in O(n). That is the two-pointer pattern: elegant, fast, and used everywhere from database joins to DNA sequencing.

The Core Idea

Place one pointer at the start (left = 0) and one at the end (right = n - 1). Each step, inspect both pointers and move one inward based on a condition. Because the array is sorted, moving a pointer always gives you meaningful information about what to try next.

Sorted: [1, 3, 5, 7, 9, 11],  target = 12

left→1  right→11  sum=12  ✓  found!

Sorted: [1, 3, 5, 7, 9, 11],  target = 10

left→1  right→11  sum=12  too big  →  right moves left
left→1  right→9   sum=10  ✓  found!

Visualising the Converging Pointers

flowchart LR
    subgraph sorted["Sorted array — Two Sum example"]
        direction LR
        A["[1]"] --- B["[3]"] --- C["[5]"] --- D["[7]"] --- E["[9]"] --- F["[11]"]
        L["left ↑\nstarts here"] -.-> A
        R["right ↑\nstarts here"] -.-> F
    end

    subgraph logic["Decision at each step"]
        direction TD
        S{"arr[left]+arr[right]\nvs target"}
        S -->|"== target"| Found["Found! Return indices"]
        S -->|"< target"| MoveL["Sum too small\nleft++"]
        S -->|"> target"| MoveR["Sum too big\nright--"]
    end

Problem 1 — Two Sum on a Sorted Array

def two_sum_sorted(arr, target):
    left  = 0
    right = len(arr) - 1

    while left < right:
        current = arr[left] + arr[right]

        if current == target:
            return left, right
        elif current < target:
            left += 1     # need a bigger sum → move left pointer right
        else:
            right -= 1    # need a smaller sum → move right pointer left

    return None   # no pair found

arr = [1, 3, 5, 7, 9, 11]
print(f"Array: {arr}")

for target in [12, 10, 20, 4]:
    result = two_sum_sorted(arr, target)
    if result:
        i, j = result
        print(f"  target={target:2d}  →  [{i}]+[{j}] = {arr[i]}+{arr[j]}")
    else:
        print(f"  target={target:2d}  →  no pair found")

Time: O(n) — each pointer moves at most n steps Space: O(1)

Trace version

def two_sum_trace(arr, target):
    left, right = 0, len(arr) - 1

    print(f"Array: {arr},  target = {target}\n")
    print(f"{'left':>5}  {'right':>6}  {'sum':>5}  action")
    print("-" * 35)

    while left < right:
        s = arr[left] + arr[right]
        if s == target:
            print(f"{left:>5}  {right:>6}  {s:>5}  FOUND: {arr[left]}+{arr[right]}")
            return left, right
        elif s < target:
            print(f"{left:>5}  {right:>6}  {s:>5}  too small → left++")
            left += 1
        else:
            print(f"{left:>5}  {right:>6}  {s:>5}  too big  → right--")
            right -= 1

    print("No pair found.")
    return None

two_sum_trace([1, 3, 5, 7, 9, 11], target=10)

Problem 2 — Remove Duplicates from a Sorted Array In-Place

Two pointers travelling in the same direction: slow marks the frontier of unique elements; fast scans ahead for the next new value.

def remove_duplicates(arr):
    if not arr:
        return 0

    slow = 0   # last position of unique elements

    for fast in range(1, len(arr)):
        if arr[fast] != arr[slow]:
            slow += 1
            arr[slow] = arr[fast]

    return slow + 1   # length of the deduplicated prefix

# Modify in-place and return new length
arr = [1, 1, 2, 3, 3, 3, 4, 5, 5]
print(f"Before: {arr}")
k = remove_duplicates(arr)
print(f"After:  {arr[:k]}")
print(f"Unique count: {k}")

arr2 = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
k2 = remove_duplicates(arr2)
print(f"\nBefore: {[0,0,1,1,1,2,2,3,3,4]}")
print(f"After:  {arr2[:k2]}")

How the two pointers move

def remove_duplicates_trace(arr):
    slow = 0
    print(f"{'fast':>5}  {'slow':>5}  arr[fast]  action")
    print("-" * 42)
    for fast in range(1, len(arr)):
        if arr[fast] != arr[slow]:
            slow += 1
            arr[slow] = arr[fast]
            action = f"NEW → write {arr[slow]} at pos {slow}"
        else:
            action = f"DUP → skip"
        print(f"{fast:>5}  {slow:>5}  {arr[fast]:>9}  {action}")
    return slow + 1

arr = [1, 1, 2, 3, 3, 4]
k = remove_duplicates_trace(arr)
print(f"\nResult: {arr[:k]}")

Problem 3 — Container With Most Water

Given heights of vertical lines at each index, find two lines that together with the x-axis hold the most water.

def max_water(heights):
    left  = 0
    right = len(heights) - 1
    best  = 0
    best_pair = (0, 0)

    while left < right:
        width  = right - left
        height = min(heights[left], heights[right])
        water  = width * height

        if water > best:
            best = water
            best_pair = (left, right)

        # Move the shorter wall — moving the taller one can only hurt
        if heights[left] < heights[right]:
            left += 1
        else:
            right -= 1

    return best, best_pair

heights = [1, 8, 6, 2, 5, 4, 8, 3, 7]
water, (l, r) = max_water(heights)
print(f"Heights: {heights}")
print(f"Max water: {water}")
print(f"Between indices {l} (h={heights[l]}) and {r} (h={heights[r]})")

Why move the shorter wall? The water level is capped by the shorter line. Making the taller line even taller changes nothing. Moving the shorter line is the only way to potentially increase the water level.

Problem 4 — Three Sum (Find All Triplets Summing to Zero)

Fix one element, then use two pointers on the rest:

def three_sum(nums):
    nums.sort()
    result = []
    n = len(nums)

    for i in range(n - 2):
        # Skip duplicate values at the fixed position
        if i > 0 and nums[i] == nums[i - 1]:
            continue

        left  = i + 1
        right = n - 1

        while left < right:
            total = nums[i] + nums[left] + nums[right]

            if total == 0:
                result.append([nums[i], nums[left], nums[right]])
                # Skip duplicates at both pointers
                while left < right and nums[left] == nums[left + 1]:
                    left += 1
                while left < right and nums[right] == nums[right - 1]:
                    right -= 1
                left  += 1
                right -= 1
            elif total < 0:
                left += 1
            else:
                right -= 1

    return result

nums = [-1, 0, 1, 2, -1, -4]
print(f"Input:   {nums}")
triplets = three_sum(nums)
print(f"Triplets summing to 0:")
for t in triplets:
    print(f"  {t}")

nums2 = [0, 0, 0, 0]
print(f"\nInput:   {nums2}")
print(f"Triplets: {three_sum(nums2)}")

Time: O(n²) — outer loop O(n), inner two-pointer O(n) Space: O(1) excluding output

Palindrome Checking

Two pointers from both ends, comparing characters as they close in:

def is_palindrome(s):
    # Normalise: keep only alphanumeric, lowercase
    cleaned = ''.join(c.lower() for c in s if c.isalnum())
    left, right = 0, len(cleaned) - 1

    while left < right:
        if cleaned[left] != cleaned[right]:
            return False
        left  += 1
        right -= 1

    return True

tests = [
    "racecar",
    "A man, a plan, a canal: Panama",
    "hello",
    "Was it a car or a cat I saw?",
    "",
]
for t in tests:
    print(f'"{t}"  →  {is_palindrome(t)}')

Real-World Applications

Database Merge Joins

When two sorted tables are joined on a common column, a database engine walks both with one pointer each — no nested loops needed. This is the merge step in merge sort, generalised to relational data.

def merge_join(table_a, table_b):
    """
    Given two sorted lists of (id, value) tuples, find all matching ids.
    Simulates a database merge join.
    """
    i, j = 0, 0
    matches = []

    while i < len(table_a) and j < len(table_b):
        id_a, val_a = table_a[i]
        id_b, val_b = table_b[j]

        if id_a == id_b:
            matches.append((id_a, val_a, val_b))
            i += 1
            j += 1
        elif id_a < id_b:
            i += 1
        else:
            j += 1

    return matches

users   = [(1, "Alice"), (3, "Bob"), (5, "Carol"), (7, "Dave")]
orders  = [(2, "laptop"), (3, "phone"), (5, "tablet"), (6, "keyboard")]

joined = merge_join(users, orders)
print(f"{'ID':>3}  {'User':>8}  {'Order':>10}")
print("-" * 28)
for uid, user, order in joined:
    print(f"{uid:>3}  {user:>8}  {order:>10}")

DNA Sequence Alignment

Checking if one DNA strand is the reverse complement of another is a classic two-pointer palindrome check:

def is_reverse_complement(strand_a, strand_b):
    """
    In DNA: A pairs with T, C pairs with G.
    strand_b is the reverse complement of strand_a if
    reading strand_b backwards gives the complement of strand_a.
    """
    complement = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}

    if len(strand_a) != len(strand_b):
        return False

    left  = 0
    right = len(strand_b) - 1

    while left < len(strand_a):
        if strand_a[left] != complement.get(strand_b[right], '?'):
            return False
        left  += 1
        right -= 1

    return True

print(is_reverse_complement("ATCG", "CGAT"))   # True
print(is_reverse_complement("AAAA", "TTTT"))   # True
print(is_reverse_complement("ATCG", "ATCG"))   # False

Complexity Summary

The two-pointer pattern works because sorted order lets each pointer movement eliminate a range of possibilities. Recognise when your input is sorted (or can be sorted cheaply) and ask whether two pointers can replace a nested loop.

Prefix Sums

Answer “what is the sum of elements from index 3 to 7?” in O(1) — after a one-time O(n) setup. Prefix sums trade a little memory for the ability to answer unlimited range queries instantly. Once you understand the trick, you will see it in financial dashboards, databases, image processing, and competitive programming alike.

The Core Idea

Build a prefix array where prefix[i] holds the sum of all elements from index 0 up to and including index i.

arr    =  [3, 1, 4, 1, 5, 9, 2, 6]
index  =   0  1  2  3  4  5  6  7

prefix =  [3, 4, 8, 9, 14, 23, 25, 31]

Now, the sum of any range [l, r] is:

range_sum(l, r) = prefix[r] - prefix[l-1]   (when l > 0)
range_sum(0, r) = prefix[r]

From Array to Prefix Array to Range Query

flowchart TD
    A["Original array\n[3, 1, 4, 1, 5, 9, 2, 6]"] --> B

    B["Build prefix array — O(n)\nprefix[i] = prefix[i-1] + arr[i]\n[3, 4, 8, 9, 14, 23, 25, 31]"] --> C

    C{"Range query\nsum(l, r)?"} --> D
    D["prefix[r] − prefix[l−1]\nO(1) per query"]

    D --> E["sum(2,5) = prefix[5]−prefix[1]\n= 23 − 4 = 19\n✓  (4+1+5+9=19)"]

Problem 1 — Range Sum Query (The Classic)

def build_prefix(arr):
    prefix = [0] * len(arr)
    prefix[0] = arr[0]
    for i in range(1, len(arr)):
        prefix[i] = prefix[i - 1] + arr[i]
    return prefix

def range_sum(prefix, l, r):
    if l == 0:
        return prefix[r]
    return prefix[r] - prefix[l - 1]

arr    = [3, 1, 4, 1, 5, 9, 2, 6]
prefix = build_prefix(arr)

print(f"Array:  {arr}")
print(f"Prefix: {prefix}\n")

queries = [(0, 7), (2, 5), (3, 3), (0, 3), (5, 7)]
for l, r in queries:
    total = range_sum(prefix, l, r)
    print(f"sum({l},{r}) = {arr[l:r+1]}  →  {total}")

Time: O(n) to build, O(1) per query Space: O(n) for the prefix array

Why this beats recomputing each time

import time
import random

arr    = [random.randint(1, 100) for _ in range(10_000)]
prefix = build_prefix(arr)

queries = [(random.randint(0, 4999), random.randint(5000, 9999)) for _ in range(10_000)]

def build_prefix(a):
    p = [0] * len(a)
    p[0] = a[0]
    for i in range(1, len(a)):
        p[i] = p[i-1] + a[i]
    return p

# Brute force: O(n) per query
t0 = time.time()
for l, r in queries:
    _ = sum(arr[l:r+1])
brute_ms = (time.time() - t0) * 1000

# Prefix sums: O(1) per query
prefix = build_prefix(arr)
t1 = time.time()
for l, r in queries:
    _ = prefix[r] - (prefix[l-1] if l > 0 else 0)
prefix_ms = (time.time() - t1) * 1000

print(f"10 000 queries on 10 000-element array:")
print(f"  Brute force:  {brute_ms:.1f} ms")
print(f"  Prefix sums:  {prefix_ms:.1f} ms")
print(f"  Speedup:      {brute_ms/max(prefix_ms,0.001):.0f}×")

Problem 2 — Number of Subarrays with Sum Equal to k

This is where prefix sums become genuinely clever. We want to count subarrays whose elements sum to exactly k.

The insight: a subarray arr[l..r] sums to k if and only if prefix[r] - prefix[l-1] == k, which means prefix[l-1] == prefix[r] - k. Use a hashmap to count how many times each prefix sum has appeared so far.

from collections import defaultdict

def count_subarrays_with_sum(arr, k):
    count = 0
    prefix_sum = 0
    freq = defaultdict(int)
    freq[0] = 1    # empty prefix has sum 0

    for x in arr:
        prefix_sum += x
        # How many previous prefix sums equal (current - k)?
        count += freq[prefix_sum - k]
        freq[prefix_sum] += 1

    return count

arr = [1, 1, 1]
print(f"Array: {arr},  k=2  →  {count_subarrays_with_sum(arr, 2)} subarrays")
# Subarrays: [1,1] at (0,1) and (1,2)  →  2

arr2 = [1, 2, 3]
print(f"Array: {arr2},  k=3  →  {count_subarrays_with_sum(arr2, 3)} subarrays")
# [3] at index 2, and [1,2] at (0,1)  →  2

arr3 = [3, 4, 7, 2, -3, 1, 4, 2]
print(f"Array: {arr3},  k=7  →  {count_subarrays_with_sum(arr3, 7)} subarrays")

Trace to see the hashmap fill up

from collections import defaultdict

def count_subarrays_trace(arr, k):
    count = 0
    prefix_sum = 0
    freq = defaultdict(int)
    freq[0] = 1

    print(f"k = {k}\n")
    print(f"{'i':>3}  {'arr[i]':>6}  {'prefix':>7}  {'need':>5}  {'found':>6}  count")
    print("-" * 50)

    for i, x in enumerate(arr):
        prefix_sum += x
        need  = prefix_sum - k
        found = freq[need]
        count += found
        freq[prefix_sum] += 1
        print(f"{i:>3}  {x:>6}  {prefix_sum:>7}  {need:>5}  {found:>6}  {count}")

    print(f"\nTotal subarrays with sum={k}: {count}")
    return count

count_subarrays_trace([1, 2, 3, 0, 3], k=3)

Problem 3 — Product of Array Except Self

For each index i, compute the product of all other elements without division and in O(n).

The trick: build a left prefix product (product of everything to the left of i) and a right suffix product (product of everything to the right). Multiply them together.

def product_except_self(arr):
    n = len(arr)
    result = [1] * n

    # Pass 1: result[i] = product of arr[0..i-1]
    prefix = 1
    for i in range(n):
        result[i] = prefix
        prefix *= arr[i]

    # Pass 2: multiply in product of arr[i+1..n-1]
    suffix = 1
    for i in range(n - 1, -1, -1):
        result[i] *= suffix
        suffix *= arr[i]

    return result

arr = [1, 2, 3, 4]
print(f"Array:   {arr}")
print(f"Product: {product_except_self(arr)}")
# [24, 12, 8, 6]
# index 0: 2*3*4=24, index 1: 1*3*4=12, etc.

arr2 = [-1, 1, 0, -3, 3]
print(f"\nArray:   {arr2}")
print(f"Product: {product_except_self(arr2)}")

Visualising the two passes

def product_except_self_trace(arr):
    n = len(arr)
    result = [1] * n

    prefix = 1
    print("Left pass (prefix products):")
    for i in range(n):
        result[i] = prefix
        prefix *= arr[i]
        print(f"  i={i}  result[{i}]={result[i]}  prefix becomes {prefix}")

    suffix = 1
    print("\nRight pass (multiply suffix):")
    for i in range(n - 1, -1, -1):
        result[i] *= suffix
        suffix *= arr[i]
        print(f"  i={i}  result[{i}]={result[i]}  suffix becomes {suffix}")

    print(f"\nFinal: {result}")
    return result

product_except_self_trace([1, 2, 3, 4])

Real-World Applications

Cumulative Sales Totals

Every business dashboard shows “sales from date A to date B”. Build the prefix once at report-generation time; every date-range query is then O(1).

def build_prefix(arr):
    p = [0] * len(arr)
    p[0] = arr[0]
    for i in range(1, len(arr)):
        p[i] = p[i-1] + arr[i]
    return p

def range_sum(prefix, l, r):
    return prefix[r] - (prefix[l-1] if l > 0 else 0)

# Daily sales for January (31 days, indexed 0–30)
daily_sales = [
    120, 95, 140, 200, 180, 160, 175,   # week 1
    130, 145, 190, 210, 170, 155, 165,   # week 2
     90, 100, 220, 195, 185, 175, 160,   # week 3
    140, 155, 200, 180, 170, 165, 175,   # week 4
    190, 195, 210                         # final days
]

prefix = build_prefix(daily_sales)

print(f"Week 1 total:  ${range_sum(prefix, 0, 6):,}")
print(f"Week 2 total:  ${range_sum(prefix, 7, 13):,}")
print(f"Week 3 total:  ${range_sum(prefix, 14, 20):,}")
print(f"Full January:  ${range_sum(prefix, 0, 30):,}")
print(f"Days 10–20:    ${range_sum(prefix, 10, 20):,}")

2D Prefix Sums — Image Integral (Computer Vision)

The same idea extends to two dimensions. The integral image (or summed-area table) is used in computer vision to compute the sum of any rectangular region of pixel values in O(1), enabling real-time face detection (Viola-Jones algorithm).

def build_2d_prefix(grid):
    rows = len(grid)
    cols = len(grid[0])
    prefix = [[0] * (cols + 1) for _ in range(rows + 1)]

    for r in range(1, rows + 1):
        for c in range(1, cols + 1):
            prefix[r][c] = (
                grid[r-1][c-1]
                + prefix[r-1][c]
                + prefix[r][c-1]
                - prefix[r-1][c-1]
            )
    return prefix

def rect_sum(prefix, r1, c1, r2, c2):
    """Sum of rectangle from (r1,c1) to (r2,c2), inclusive, 0-indexed."""
    return (
        prefix[r2+1][c2+1]
        - prefix[r1][c2+1]
        - prefix[r2+1][c1]
        + prefix[r1][c1]
    )

# 5x5 grayscale pixel values (0-255)
image = [
    [10, 20, 30, 40, 50],
    [15, 25, 35, 45, 55],
    [20, 30, 40, 50, 60],
    [25, 35, 45, 55, 65],
    [30, 40, 50, 60, 70],
]

prefix = build_2d_prefix(image)

# Sum of a 3x3 region starting at (1,1)
total = rect_sum(prefix, 1, 1, 3, 3)
print(f"Sum of rectangle (1,1)→(3,3): {total}")

# Verify by brute force
brute = sum(image[r][c] for r in range(1, 4) for c in range(1, 4))
print(f"Brute force verification:      {brute}")
print(f"Match: {total == brute}")

# Full image sum in O(1)
print(f"Full image sum: {rect_sum(prefix, 0, 0, 4, 4)}")

Complexity Summary

* Two extra O(1) variables for prefix/suffix; result array is required output, not overhead.

Prefix sums embody a core engineering trade-off: spend O(n) time and O(n) space once, then answer queries in O(1) forever. Whenever you find yourself recomputing the same running total across many queries, ask whether a prefix array can replace the loop.

Array Problems

Practice problems for the Arrays section. Each problem includes multiple approaches, from brute force to optimal.

Max Consecutive Ones

Difficulty: Easy Source: NeetCode

Problem

Given a binary array nums, return the maximum number of consecutive 1s in the array.

Example 1: Input: nums = [1, 1, 0, 1, 1, 1] Output: 3

Example 2: Input: nums = [1, 0, 1, 1, 0, 1] Output: 2

Constraints:

• 1 <= nums.length <= 10^5
• nums[i] is either 0 or 1

Prerequisites

Before attempting this problem, you should be comfortable with:

• Arrays — understanding how to traverse and access array elements sequentially
• Basic Iteration — using loops to scan through elements and track state with counters

1. Brute Force

Intuition

For each position in the array, count how many consecutive 1s start from that position. Scan forward until hitting a 0 or the end of the array, then track the maximum count seen. This straightforward approach checks every possible starting position.

Algorithm

1. Initialize res = 0 to track the maximum consecutive ones.
2. For each starting index i:
   • Initialize a counter cnt = 0.
   • Scan forward from i while the current element is 1, incrementing cnt.
   • Stop when encountering a 0 or reaching the end.
   • Update res = max(res, cnt).
3. Return res.

Solution

def findMaxConsecutiveOnes(nums):
    n, res = len(nums), 0

    for i in range(n):
        cnt = 0
        for j in range(i, n):
            if nums[j] == 0:
                break
            cnt += 1
        res = max(res, cnt)

    return res


print(findMaxConsecutiveOnes([1, 1, 0, 1, 1, 1]))  # 3
print(findMaxConsecutiveOnes([1, 0, 1, 1, 0, 1]))  # 2

Complexity

• Time: O(n²)
• Space: O(1)

2. Iteration — I

Intuition

Only one pass through the array is needed. Maintain a running count of consecutive 1s. When we see a 1, increment the count. When we see a 0, compare the current count with the maximum, then reset to 0. After the loop, do one final comparison — the longest sequence might end at the last element.

Algorithm

1. Initialize res = 0 and cnt = 0.
2. Iterate through each element in the array:
   • If the element is 0: update res = max(res, cnt), then reset cnt = 0.
   • If the element is 1: increment cnt.
3. Return max(cnt, res) — handles sequences that end at the last element.

Solution

def findMaxConsecutiveOnes(nums):
    res = cnt = 0
    for num in nums:
        if num == 0:
            res = max(res, cnt)
            cnt = 0
        else:
            cnt += 1

    return max(cnt, res)


print(findMaxConsecutiveOnes([1, 1, 0, 1, 1, 1]))  # 3
print(findMaxConsecutiveOnes([1, 0, 1, 1, 0, 1]))  # 2

Complexity

• Time: O(n)
• Space: O(1)

3. Iteration — II

Intuition

Simplify the logic by updating the maximum on every step. If we see a 1, increment the count; otherwise reset it to 0. Updating res after each element eliminates the need for a final comparison after the loop.

Algorithm

1. Initialize res = 0 and cnt = 0.
2. For each element in the array:
   • If the element is 1: increment cnt.
   • Otherwise: set cnt = 0.
   • Update res = max(res, cnt).
3. Return res.

Solution

def findMaxConsecutiveOnes(nums):
    res = cnt = 0
    for num in nums:
        cnt += 1 if num else -cnt
        res = max(res, cnt)
    return res


print(findMaxConsecutiveOnes([1, 1, 0, 1, 1, 1]))  # 3
print(findMaxConsecutiveOnes([1, 0, 1, 1, 0, 1]))  # 2

Complexity

• Time: O(n)
• Space: O(1)

Common Pitfalls

Forgetting the final comparison. When using Iteration — I, the longest sequence might end at the last element. If you only update res when hitting a 0, that final run is never captured. Always compare cnt with res after the loop ends — or use Iteration — II which updates res on every step.

Resetting the counter to 1 instead of 0. When a 0 is encountered, cnt must reset to 0. The next 1 will increment it to 1. Resetting to 1 skips that increment and causes an off-by-one error.

Remove Element

Difficulty: Easy Source: NeetCode

Problem

Given an integer array nums and an integer val, remove all occurrences of val in nums in-place. The order of the elements may be changed. Return k — the number of elements in nums that are not equal to val.

The first k elements of nums must contain the elements which are not equal to val. The remaining elements and the size of the array do not matter.

Example 1: Input: nums = [3, 2, 2, 3], val = 3 Output: 2, nums = [2, 2, _, _]

Example 2: Input: nums = [0, 1, 2, 2, 3, 0, 4, 2], val = 2 Output: 5, nums = [0, 1, 3, 0, 4, _, _, _]

Constraints:

• 0 <= nums.length <= 100
• 0 <= nums[i] <= 50
• 0 <= val <= 100

Prerequisites

Before attempting this problem, you should be comfortable with:

• Arrays — understanding in-place modification and index-based access
• Two Pointers — using separate read and write indices to process an array in a single pass

1. Brute Force

Intuition

When an element equal to val is found, shift every element after it one position to the left to fill the gap, then shrink the logical length by one. Repeat until the full array has been scanned. This mimics how a naive deletion from a static array works.

Algorithm

1. Set k = len(nums) as the logical length.
2. Set i = 0. While i < k:
   • If nums[i] == val, shift all elements from i+1 to k-1 one position left, then decrement k.
   • Otherwise, increment i.
3. Return k.

Solution

def removeElement(nums, val):
    k = len(nums)
    i = 0
    while i < k:
        if nums[i] == val:
            for j in range(i + 1, k):
                nums[j - 1] = nums[j]
            k -= 1
        else:
            i += 1
    return k


nums = [3, 2, 2, 3]
k = removeElement(nums, 3)
print(k, nums[:k])  # 2 [2, 2]

nums = [0, 1, 2, 2, 3, 0, 4, 2]
k = removeElement(nums, 2)
print(k, nums[:k])  # 5 [0, 1, 3, 0, 4]

Complexity

• Time: O(n²)
• Space: O(1)

2. Two Pointers

Intuition

Use two pointers: a write pointer k that tracks where the next kept element should go, and a read pointer that iterates through every element. Whenever the current element is not val, copy it to position k and advance k. Elements equal to val are simply skipped. One pass through the array is enough.

Algorithm

1. Initialize k = 0 as the write pointer.
2. For each element num in nums:
   • If num != val: write num to nums[k], then increment k.
3. Return k.

flowchart LR
    S(["nums=[3,2,2,3]  val=3  k=0"])
    S --> i0["i=0  →  3 = val  →  skip"]
    i0 --> i1["i=1  →  2 ≠ val  →  nums[0]=2   k=1"]
    i1 --> i2["i=2  →  2 ≠ val  →  nums[1]=2   k=2"]
    i2 --> i3["i=3  →  3 = val  →  skip"]
    i3 --> R(["return k=2   nums[:2]=[2,2]"])

Solution

def removeElement(nums, val):
    k = 0
    for num in nums:
        if num != val:
            nums[k] = num
            k += 1
    return k


nums = [3, 2, 2, 3]
k = removeElement(nums, 3)
print(k, nums[:k])  # 2 [2, 2]

nums = [0, 1, 2, 2, 3, 0, 4, 2]
k = removeElement(nums, 2)
print(k, nums[:k])  # 5 [0, 1, 3, 0, 4]

Complexity

• Time: O(n)
• Space: O(1)

3. Two Pointers — II

Intuition

When there are few elements to remove, the previous approach does unnecessary copying — it rewrites every non-val element even if it is already in the right place. Instead, swap unwanted elements with the element at the end of the valid range and shrink that range by one. This minimises write operations when removals are rare.

Algorithm

1. Initialize i = 0 as the current position and n = len(nums) as the effective length.
2. While i < n:
   • If nums[i] == val: overwrite it with nums[n - 1] and decrement n. Do not increment i — the swapped-in element still needs to be checked.
   • Otherwise: increment i.
3. Return n.

flowchart LR
    subgraph T0["Initial   i=0   n=4"]
        A0["3"] --- A1["2"] --- A2["2"] --- A3["3"]
    end
    subgraph T1["i=0  3=val  →  nums[0]=nums[3]   n=3"]
        B0["3"] --- B1["2"] --- B2["2"] --- B3["·"]
    end
    subgraph T2["i=0  3=val  →  nums[0]=nums[2]   n=2"]
        C0["2"] --- C1["2"] --- C2["·"] --- C3["·"]
    end
    subgraph T3["i=0,1 advance  →  i=2 ≥ n=2  →  stop"]
        D0["2"] --- D1["2"]
    end
    T0 --> T1 --> T2 --> T3

Solution

def removeElement(nums, val):
    i = 0
    n = len(nums)
    while i < n:
        if nums[i] == val:
            n -= 1
            nums[i] = nums[n]
        else:
            i += 1
    return n


nums = [3, 2, 2, 3]
k = removeElement(nums, 3)
print(k, nums[:k])  # 2 [2, 2]

nums = [0, 1, 2, 2, 3, 0, 4, 2]
k = removeElement(nums, 2)
print(k, nums[:k])  # 5 [0, 1, 3, 0, 4]

Complexity

• Time: O(n)
• Space: O(1)

When to prefer this over Two Pointers — I? When val is rare, this approach writes far fewer elements. If the array has 10 000 elements and only 2 match val, Two Pointers — I still copies 9 998 elements; this approach writes only 2.

Common Pitfalls

Indexing into nums after returning k. The problem only guarantees that the first k elements are correct. Elements at index k and beyond are considered garbage — do not read or compare them.

Modifying nums length directly. Python lists support del and remove(), but the problem requires in-place modification that works within the array’s original memory. Avoid creating a new list; overwrite in place and track k yourself.

Off-by-one when using k as a slice bound. nums[:k] is correct because k is the count of valid elements, which equals the exclusive upper bound of the slice.

Concatenation of Array

Difficulty: Easy Source: NeetCode

Problem

Given an integer array nums of length n, return an array ans of length 2n where ans[i] = nums[i] and ans[i + n] = nums[i] for 0 <= i < n.

In other words, ans is the concatenation of two copies of nums.

Example 1: Input: nums = [1, 2, 1] Output: [1, 2, 1, 1, 2, 1]

Example 2: Input: nums = [1, 3, 2, 1] Output: [1, 3, 2, 1, 1, 3, 2, 1]

Constraints:

• 1 <= n <= 1000
• 1 <= nums[i] <= 1000

Prerequisites

Before attempting this problem, you should be comfortable with:

• Arrays — understanding index-based access and iteration
• Array concatenation — combining arrays or building new ones by index

1. Brute Force

Intuition

Build the result array manually by iterating twice. On the first pass, place each element of nums at index i. On the second pass, place the same elements at index i + n. This makes the logic explicit and easy to follow, even if Python gives us a nicer shortcut.

Algorithm

1. Create ans as a list of zeros with length 2 * n.
2. Loop i from 0 to n - 1:
   • Set ans[i] = nums[i]
   • Set ans[i + n] = nums[i]
3. Return ans.

Solution

def getConcatenation(nums):
    n = len(nums)
    ans = [0] * (2 * n)
    for i in range(n):
        ans[i] = nums[i]
        ans[i + n] = nums[i]
    return ans


print(getConcatenation([1, 2, 1]))        # [1, 2, 1, 1, 2, 1]
print(getConcatenation([1, 3, 2, 1]))     # [1, 3, 2, 1, 1, 3, 2, 1]
print(getConcatenation([5]))              # [5, 5]

Complexity

• Time: O(n)
• Space: O(n) — the output array of length 2n

2. Python Concatenation Operator

Intuition

Python’s + operator on lists creates a new list that is the concatenation of both operands. Since we want nums followed by nums, we can just return nums + nums — one line, same time and space complexity as the manual approach, just more readable.

This is not a “trick” — it’s the same algorithm underneath. The + operator iterates through both lists and copies each element into a new list, which is exactly what the brute force does.

Algorithm

1. Return nums + nums.

flowchart LR
    A(["nums = [1, 2, 1]"]) --> B["nums + nums"]
    B --> C(["[1, 2, 1, 1, 2, 1]"])

Solution

def getConcatenation(nums):
    return nums + nums


print(getConcatenation([1, 2, 1]))        # [1, 2, 1, 1, 2, 1]
print(getConcatenation([1, 3, 2, 1]))     # [1, 3, 2, 1, 1, 3, 2, 1]
print(getConcatenation([5]))              # [5, 5]

Complexity

• Time: O(n)
• Space: O(n) — output array of length 2n

Common Pitfalls

Using nums * 2 vs nums + nums. Both produce the same result for this problem, but understand that nums * 2 also creates a new list — it does not mutate nums in place. Either works fine here.

Mutating nums in place. If you try to append to nums directly inside a loop over nums, you will get an infinite loop since the list grows as you iterate. Always build a separate output or use nums + nums to create a new list.

Contains Duplicate

Difficulty: Easy Source: NeetCode

Problem

Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.

Example 1: Input: nums = [1, 2, 3, 1] Output: true

Example 2: Input: nums = [1, 2, 3, 4] Output: false

Example 3: Input: nums = [1, 1, 1, 3, 3, 4, 3, 2, 4, 2] Output: true

Constraints:

• 1 <= nums.length <= 10^5
• -10^9 <= nums[i] <= 10^9

Prerequisites

Before attempting this problem, you should be comfortable with:

• Arrays — iteration and element access
• Hash Sets — O(1) average-case lookup and insertion

1. Brute Force

Intuition

For every element in the array, check every other element that comes after it. If any two elements are equal, return true. This guarantees correctness but checks every possible pair — which is slow for large arrays.

Algorithm

1. For each index i from 0 to n - 1:
   • For each index j from i + 1 to n - 1:
     • If nums[i] == nums[j], return true.
2. Return false (no duplicate found).

Solution

def containsDuplicate(nums):
    n = len(nums)
    for i in range(n):
        for j in range(i + 1, n):
            if nums[i] == nums[j]:
                return True
    return False


print(containsDuplicate([1, 2, 3, 1]))              # True
print(containsDuplicate([1, 2, 3, 4]))              # False
print(containsDuplicate([1, 1, 1, 3, 3, 4, 3]))    # True

Complexity

• Time: O(n²) — every pair of elements is compared
• Space: O(1)

2. Sorting

Intuition

If you sort the array first, any duplicate values will end up sitting next to each other. A single pass checking adjacent elements is then all you need. The cost is the sort itself.

Algorithm

1. Sort nums.
2. For each index i from 1 to n - 1:
   • If nums[i] == nums[i - 1], return true.
3. Return false.

Solution

def containsDuplicate(nums):
    nums.sort()
    for i in range(1, len(nums)):
        if nums[i] == nums[i - 1]:
            return True
    return False


print(containsDuplicate([1, 2, 3, 1]))              # True
print(containsDuplicate([1, 2, 3, 4]))              # False
print(containsDuplicate([1, 1, 1, 3, 3, 4, 3]))    # True

Complexity

• Time: O(n log n) — dominated by the sort
• Space: O(1) — ignoring the sort’s stack space

3. Hash Set

Intuition

As you scan through the array, keep track of every number you have seen so far in a hash set. Before adding a number, check if it is already in the set. If it is, you have found a duplicate — return true immediately. Hash set lookups and insertions are O(1) on average, so the whole scan is O(n).

Algorithm

1. Create an empty set seen.
2. For each num in nums:
   • If num is in seen, return true.
   • Otherwise, add num to seen.
3. Return false.

flowchart LR
    S(["nums=[1,2,3,1]   seen={}"])
    S --> i0["num=1  →  not in seen  →  seen={1}"]
    i0 --> i1["num=2  →  not in seen  →  seen={1,2}"]
    i1 --> i2["num=3  →  not in seen  →  seen={1,2,3}"]
    i2 --> i3["num=1  →  1 in seen!  →  return True"]

Solution

def containsDuplicate(nums):
    seen = set()
    for num in nums:
        if num in seen:
            return True
        seen.add(num)
    return False


print(containsDuplicate([1, 2, 3, 1]))              # True
print(containsDuplicate([1, 2, 3, 4]))              # False
print(containsDuplicate([1, 1, 1, 3, 3, 4, 3]))    # True

Complexity

• Time: O(n) — one pass with O(1) set operations
• Space: O(n) — worst case: all elements are unique and all end up in the set

Common Pitfalls

Using len(set(nums)) != len(nums). This works and is Pythonic, but it builds the entire set before checking — meaning it never short-circuits early when a duplicate is found near the start. The explicit loop with early return is faster in practice for arrays with early duplicates.

Assuming integers are bounded. The hash set approach works for any hashable type. If someone asks you to use O(1) space, the sorting approach is a good trade-off (though it modifies the input).

Valid Anagram

Difficulty: Easy Source: NeetCode

Problem

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

An anagram is a word formed by rearranging the letters of a different word using all the original letters exactly once.

Example 1: Input: s = "anagram", t = "nagaram" Output: true

Example 2: Input: s = "rat", t = "car" Output: false

Constraints:

• 1 <= s.length, t.length <= 5 * 10^4
• s and t consist of lowercase English letters.

Prerequisites

Before attempting this problem, you should be comfortable with:

• Strings — iteration and character access
• Hash Maps — storing and comparing frequency counts
• Sorting — understanding the cost of sorting a sequence

1. Brute Force (Sorting)

Intuition

Two strings are anagrams of each other if and only if they contain the exact same characters with the exact same frequencies. Sorting both strings rearranges all characters into a canonical order — if the sorted versions are equal, the strings are anagrams. Short-circuit immediately if the lengths differ.

Algorithm

1. If len(s) != len(t), return false.
2. Sort both strings.
3. Return sorted(s) == sorted(t).

Solution

def isAnagram(s, t):
    if len(s) != len(t):
        return False
    return sorted(s) == sorted(t)


print(isAnagram("anagram", "nagaram"))   # True
print(isAnagram("rat", "car"))           # False
print(isAnagram("ab", "a"))              # False

Complexity

• Time: O(n log n) — dominated by sorting, where n = len(s)
• Space: O(n) — sorted copies of each string

2. Frequency Count (Hash Map)

Intuition

Instead of sorting, count how many times each character appears in s, then subtract counts for each character in t. If every count ends at zero, the strings are anagrams. We only need one hash map — increment for characters in s, decrement for characters in t, and check that all values are zero at the end.

Algorithm

1. If len(s) != len(t), return false.
2. Create a hash map count (default 0).
3. For each character c in s, increment count[c].
4. For each character c in t, decrement count[c].
5. Return true if all values in count are 0.

flowchart LR
    A(["s='rat'   t='car'"])
    A --> B["count r=1 a=1 t=1  after s"]
    B --> C["subtract t: c=-1 a=0 r=0 t=1"]
    C --> D{"all zero?"}
    D -- No --> E(["return False"])

Solution

def isAnagram(s, t):
    if len(s) != len(t):
        return False

    count = {}
    for c in s:
        count[c] = count.get(c, 0) + 1
    for c in t:
        count[c] = count.get(c, 0) - 1

    return all(v == 0 for v in count.values())


print(isAnagram("anagram", "nagaram"))   # True
print(isAnagram("rat", "car"))           # False
print(isAnagram("ab", "a"))              # False

Complexity

• Time: O(n) — two passes over strings of length n
• Space: O(1) — at most 26 distinct lowercase letters in the map

3. Fixed-Size Count Array

Intuition

Since the problem guarantees lowercase English letters only, we can use a list of 26 integers instead of a hash map. Map each character to an index via ord(c) - ord('a'). This avoids hash overhead and is cache-friendly.

Algorithm

1. If len(s) != len(t), return false.
2. Create count = [0] * 26.
3. For each character c in s, increment count[ord(c) - ord('a')].
4. For each character c in t, decrement count[ord(c) - ord('a')].
5. Return true if all entries in count are 0.

Solution

def isAnagram(s, t):
    if len(s) != len(t):
        return False

    count = [0] * 26
    for c in s:
        count[ord(c) - ord('a')] += 1
    for c in t:
        count[ord(c) - ord('a')] -= 1

    return all(x == 0 for x in count)


print(isAnagram("anagram", "nagaram"))   # True
print(isAnagram("rat", "car"))           # False
print(isAnagram("ab", "a"))              # False

Complexity

• Time: O(n)
• Space: O(1) — fixed array of 26 integers regardless of input size

Common Pitfalls

Forgetting the length check. If s and t have different lengths, they cannot be anagrams. Checking length first lets you return early and avoids subtle bugs in the count comparison.

Handling Unicode. The problem restricts input to lowercase ASCII letters, so the 26-element array works. If the problem allowed Unicode, you would need a general hash map — the fixed array approach would fail silently on characters outside a-z.

Using Counter directly. from collections import Counter; return Counter(s) == Counter(t) is valid and clean, but understanding the underlying frequency-count approach is more important for interviews.

Two Sum

Difficulty: Easy Source: NeetCode

Problem

Given an array of integers nums and an integer target, return the indices of the two numbers such that they add up to target.

You may assume that each input has exactly one solution, and you may not use the same element twice. You can return the answer in any order.

Example 1: Input: nums = [2, 7, 11, 15], target = 9 Output: [0, 1]

Example 2: Input: nums = [3, 2, 4], target = 6 Output: [1, 2]

Example 3: Input: nums = [3, 3], target = 6 Output: [0, 1]

Constraints:

• 2 <= nums.length <= 10^4
• -10^9 <= nums[i] <= 10^9
• -10^9 <= target <= 10^9
• Only one valid answer exists.

Prerequisites

Before attempting this problem, you should be comfortable with:

• Arrays — index-based access and iteration
• Hash Maps — O(1) average-case lookup for key-value pairs
• Complement — the idea that if a + b = target, then b = target - a

1. Brute Force

Intuition

Try every possible pair of indices (i, j) where i < j. Check if the two elements at those positions sum to target. The first matching pair is returned. This is correct but slow because it examines all n*(n-1)/2 pairs.

Algorithm

1. For each index i from 0 to n - 1:
   • For each index j from i + 1 to n - 1:
     • If nums[i] + nums[j] == target, return [i, j].
2. Return [] (problem guarantees a solution exists, so this is unreachable).

Solution

def twoSum(nums, target):
    n = len(nums)
    for i in range(n):
        for j in range(i + 1, n):
            if nums[i] + nums[j] == target:
                return [i, j]
    return []


print(twoSum([2, 7, 11, 15], 9))   # [0, 1]
print(twoSum([3, 2, 4], 6))        # [1, 2]
print(twoSum([3, 3], 6))           # [0, 1]

Complexity

• Time: O(n²)
• Space: O(1)

2. Hash Map (One Pass)

Intuition

For each number nums[i], we need to know if its complement — target - nums[i] — has already been seen. A hash map lets us check this in O(1). As we scan left to right, we store each number and its index in the map. Before storing, we check whether the complement is already there. If it is, we are done.

The key insight: we only ever need to look backwards (at elements already processed), so a single left-to-right pass is enough.

Algorithm

1. Create an empty hash map seen mapping value → index.
2. For each index i and value num in nums:
   • Compute complement = target - num.
   • If complement is in seen, return [seen[complement], i].
   • Otherwise, store seen[num] = i.
3. Return [].

flowchart LR
    S(["nums=[2,7,11,15]  target=9  seen={}"])
    S --> i0["i=0  num=2  comp=7  →  7 not in seen  →  seen={2:0}"]
    i0 --> i1["i=1  num=7  comp=2  →  2 in seen!  →  return [0,1]"]

Solution

def twoSum(nums, target):
    seen = {}  # value -> index
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []


print(twoSum([2, 7, 11, 15], 9))   # [0, 1]
print(twoSum([3, 2, 4], 6))        # [1, 2]
print(twoSum([3, 3], 6))           # [0, 1]

Complexity

• Time: O(n) — one pass, each hash map operation is O(1) average
• Space: O(n) — the hash map stores at most n entries

Common Pitfalls

Using the same element twice. If target = 6 and nums[0] = 3, you might incorrectly find the complement 3 at index 0 itself. The one-pass hash map approach avoids this naturally — we only look at elements already seen, and nums[0] has not been added to the map yet when we check its complement.

Returning values instead of indices. The problem asks for indices, not the numbers themselves. Make sure your hash map stores value → index, not the reverse.

Assuming the array is sorted. The two-pointer approach for sorted arrays would give O(n) time and O(1) space, but it only works if the array is sorted. Two Sum does not guarantee sorted input, so you would need to sort first (losing the original indices) or use the hash map approach.

Longest Common Prefix

Difficulty: Easy Source: NeetCode

Problem

Write a function to find the longest common prefix string amongst an array of strings.

If there is no common prefix, return an empty string "".

Example 1: Input: strs = ["flower", "flow", "flight"] Output: "fl"

Example 2: Input: strs = ["dog", "racecar", "car"] Output: ""

Constraints:

• 1 <= strs.length <= 200
• 0 <= strs[i].length <= 200
• strs[i] consists of only lowercase English letters.

Prerequisites

Before attempting this problem, you should be comfortable with:

• Strings — character-by-character comparison and slicing
• Iteration — looping over multiple collections simultaneously

1. Brute Force (Character-by-Character)

Intuition

Take the first string as the initial candidate prefix. Then for each subsequent string, shorten the candidate until it matches the beginning of that string. After processing all strings, whatever remains is the longest common prefix.

Alternatively: pick any column index c. If the character at column c is the same in all strings, it is part of the prefix. The moment we find a mismatch — or run off the end of any string — we stop.

Algorithm

1. If strs is empty, return "".
2. Set prefix = strs[0].
3. For each string s in strs[1:]:
   • While s does not start with prefix, remove the last character from prefix.
   • If prefix becomes empty, return "".
4. Return prefix.

Solution

def longestCommonPrefix(strs):
    if not strs:
        return ""
    prefix = strs[0]
    for s in strs[1:]:
        while not s.startswith(prefix):
            prefix = prefix[:-1]
            if not prefix:
                return ""
    return prefix


print(longestCommonPrefix(["flower", "flow", "flight"]))   # "fl"
print(longestCommonPrefix(["dog", "racecar", "car"]))      # ""
print(longestCommonPrefix(["interview", "inter", "internal"]))  # "inter"

Complexity

• Time: O(S) where S is the total number of characters across all strings (worst case: all strings identical)
• Space: O(1) extra (we reuse the prefix string in-place)

2. Sort and Compare Endpoints

Intuition

If you sort the array of strings lexicographically, the first and last strings will be the most different from each other. Any character that matches between the first and last string also matches in every string in between. So comparing just those two strings tells you the longest common prefix for the whole array.

This is a clever observation: you do not need to compare all pairs — just the extreme ends after sorting.

Algorithm

1. Sort strs lexicographically.
2. Compare the first string lo = strs[0] and the last string hi = strs[-1] character by character.
3. Find the length of their common prefix.
4. Return the prefix.

flowchart LR
    A(["strs = ['flower','flow','flight']"])
    A --> B["sort → ['flight','flow','flower']"]
    B --> C["compare 'flight' vs 'flower'"]
    C --> D["f=f ✓  l=l ✓  i≠o ✗  stop at index 2"]
    D --> E(["return 'fl'"])

Solution

def longestCommonPrefix(strs):
    if not strs:
        return ""
    strs.sort()
    lo, hi = strs[0], strs[-1]
    i = 0
    while i < len(lo) and i < len(hi) and lo[i] == hi[i]:
        i += 1
    return lo[:i]


print(longestCommonPrefix(["flower", "flow", "flight"]))         # "fl"
print(longestCommonPrefix(["dog", "racecar", "car"]))            # ""
print(longestCommonPrefix(["interview", "inter", "internal"]))   # "inter"

Complexity

• Time: O(n log n) for the sort, plus O(m) for the comparison where m is the length of the shortest string
• Space: O(1) extra

Common Pitfalls

Empty array or single string. If strs has one element, its entire value is the common prefix. Make sure your code handles this edge case — the sort-and-compare approach naturally handles it because lo and hi are the same string.

Prefix becoming empty. When no common character exists at position 0, the answer is "". The trimming approach handles this cleanly via the while not prefix: return "" check.

Off-by-one on string length. When comparing two strings, stop when i reaches the length of the shorter string. Accessing lo[i] beyond its length would raise an IndexError.

Group Anagrams

Difficulty: Medium Source: NeetCode

Problem

Given an array of strings strs, group the anagrams together. You can return the answer in any order.

An anagram is a word formed by rearranging the letters of a different word using all the original letters exactly once.

Example 1: Input: strs = ["eat","tea","tan","ate","nat","bat"] Output: [["bat"],["nat","tan"],["ate","eat","tea"]]

Example 2: Input: strs = [""] Output: [[""]]

Example 3: Input: strs = ["a"] Output: [["a"]]

Constraints:

• 1 <= strs.length <= 10^4
• 0 <= strs[i].length <= 100
• strs[i] consists of lowercase English letters.

Prerequisites

Before attempting this problem, you should be comfortable with:

• Hash Maps — grouping items by a shared key
• Sorting — using sorted strings as canonical keys
• Tuples as dictionary keys — immutable sequences that can be hashed

1. Brute Force (Sort Each String as Key)

Intuition

Two strings are anagrams if and only if their sorted versions are identical. For example, "eat", "tea", and "ate" all sort to "aet". We can use the sorted string as a dictionary key and group all strings that share the same key together.

This is actually quite efficient in practice — sorting each individual word is cheap, and the overall grouping work is linear in total characters.

Algorithm

1. Create a hash map groups where key → list of strings.
2. For each string s in strs:
   • Compute key = "".join(sorted(s)).
   • Append s to groups[key].
3. Return the values of groups.

Solution

from collections import defaultdict

def groupAnagrams(strs):
    groups = defaultdict(list)
    for s in strs:
        key = "".join(sorted(s))
        groups[key].append(s)
    return list(groups.values())


print(groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"]))
# [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

print(groupAnagrams([""]))    # [['']]
print(groupAnagrams(["a"]))   # [['a']]

Complexity

• Time: O(n * k log k) where n is the number of strings and k is the maximum string length (sorting each string)
• Space: O(n * k) — storing all strings in the map

2. Character Count Tuple as Key

Intuition

Instead of sorting (which costs O(k log k) per string), we can count the frequency of each of the 26 letters in the string. Two strings are anagrams if and only if they have the same character frequencies. Represent these 26 counts as a tuple and use that as the dictionary key. Tuple creation is O(k), which is better than sorting.

Algorithm

1. Create a hash map groups where key → list of strings.
2. For each string s in strs:
   • Create a count array of 26 zeros.
   • For each character c in s, increment count[ord(c) - ord('a')].
   • Convert count to a tuple (tuples are hashable; lists are not).
   • Append s to groups[tuple(count)].
3. Return the values of groups.

flowchart LR
    A(["'eat'  →  count[e]=1, a=1, t=1  →  tuple (1,0,0,...,1,...,1,...)"])
    B(["'tea'  →  same counts  →  same tuple"])
    C(["'tan'  →  count[t]=1, a=1, n=1  →  different tuple"])
    A --> G["same group"]
    B --> G
    C --> H["different group"]

Solution

from collections import defaultdict

def groupAnagrams(strs):
    groups = defaultdict(list)
    for s in strs:
        count = [0] * 26
        for c in s:
            count[ord(c) - ord('a')] += 1
        groups[tuple(count)].append(s)
    return list(groups.values())


print(groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"]))
# [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

print(groupAnagrams([""]))    # [['']]
print(groupAnagrams(["a"]))   # [['a']]

Complexity

• Time: O(n * k) — for each of n strings, we do O(k) work to build the count
• Space: O(n * k) — storing all strings and keys

Common Pitfalls

Using a list as a dictionary key. Lists are mutable and therefore not hashable in Python. You must convert the count array to a tuple before using it as a key — this is a very common mistake.

Not using defaultdict. With a regular dict, you need to check if key not in groups: groups[key] = [] before appending. Using defaultdict(list) handles this automatically and makes the code cleaner.

Assuming the output order matters. The problem says the answer can be in any order — so do not worry about sorting the groups or the strings within each group unless explicitly asked.

Majority Element

Difficulty: Easy Source: NeetCode

Problem

Given an array nums of size n, return the majority element.

The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array.

Example 1: Input: nums = [3, 2, 3] Output: 3

Example 2: Input: nums = [2, 2, 1, 1, 1, 2, 2] Output: 2

Constraints:

• n == nums.length
• 1 <= n <= 5 * 10^4
• -10^9 <= nums[i] <= 10^9
• The majority element always exists.

Prerequisites

Before attempting this problem, you should be comfortable with:

• Hash Maps — counting element frequencies
• Voting / Cancellation intuition — understanding why majority elements survive pairwise elimination

1. Brute Force (Hash Map Count)

Intuition

Count the occurrences of each element using a hash map, then find the element whose count exceeds n / 2. This is straightforward and easy to reason about — scan once to count, then scan the map to find the winner.

Algorithm

1. Build a frequency map count over nums.
2. For each element num and its freq in count:
   • If freq > n // 2, return num.
3. (Unreachable — the problem guarantees a majority element exists.)

Solution

def majorityElement(nums):
    n = len(nums)
    count = {}
    for num in nums:
        count[num] = count.get(num, 0) + 1
    for num, freq in count.items():
        if freq > n // 2:
            return num
    return -1  # unreachable


print(majorityElement([3, 2, 3]))               # 3
print(majorityElement([2, 2, 1, 1, 1, 2, 2]))  # 2
print(majorityElement([1]))                     # 1

Complexity

• Time: O(n)
• Space: O(n) — the hash map can hold up to n distinct elements

2. Sorting

Intuition

If the majority element appears more than n/2 times, after sorting it must occupy the middle index n // 2. No matter how the other elements are arranged, the majority element has enough copies to span past the midpoint.

Algorithm

1. Sort nums.
2. Return nums[n // 2].

Solution

def majorityElement(nums):
    nums.sort()
    return nums[len(nums) // 2]


print(majorityElement([3, 2, 3]))               # 3
print(majorityElement([2, 2, 1, 1, 1, 2, 2]))  # 2
print(majorityElement([1]))                     # 1

Complexity

• Time: O(n log n) — dominated by sorting
• Space: O(1) — ignoring sort stack space

3. Boyer-Moore Voting Algorithm

Intuition

Imagine pairing up different elements and cancelling each pair. Since the majority element appears more than half the time, it always survives this cancellation process — there are simply too many copies of it for all of them to be cancelled out by other elements.

Maintain a candidate and a count. When count hits zero, pick the current element as the new candidate. If the current element matches the candidate, increment count; otherwise, decrement it. By the end, the candidate is guaranteed to be the majority element.

Algorithm

1. Set candidate = None, count = 0.
2. For each num in nums:
   • If count == 0, set candidate = num.
   • If num == candidate, increment count.
   • Otherwise, decrement count.
3. Return candidate.

flowchart LR
    S(["nums=[2,2,1,1,1,2,2]   candidate=None  count=0"])
    S --> a["num=2  count=0  →  candidate=2  count=1"]
    a --> b["num=2  match  →  count=2"]
    b --> c["num=1  no match  →  count=1"]
    c --> d["num=1  no match  →  count=0"]
    d --> e["num=1  count=0  →  candidate=1  count=1"]
    e --> f["num=2  no match  →  count=0"]
    f --> g["num=2  count=0  →  candidate=2  count=1"]
    g --> R(["return candidate=2"])

Solution

def majorityElement(nums):
    candidate = None
    count = 0
    for num in nums:
        if count == 0:
            candidate = num
        count += 1 if num == candidate else -1
    return candidate


print(majorityElement([3, 2, 3]))               # 3
print(majorityElement([2, 2, 1, 1, 1, 2, 2]))  # 2
print(majorityElement([1]))                     # 1

Complexity

• Time: O(n) — single pass
• Space: O(1) — only two variables

Common Pitfalls

Boyer-Moore requires a guaranteed majority. The algorithm returns the candidate but does not verify it. If the problem did not guarantee a majority element exists, you would need a second pass to count and confirm. For this problem, verification is not needed.

Confusing n // 2 with n / 2. In Python 3, / gives float division. Use // for integer floor division when checking freq > n // 2.

Design HashSet

Difficulty: Easy Source: NeetCode

Problem

Design a HashSet without using any built-in hash table libraries.

Implement the MyHashSet class:

• add(key) — Inserts the value key into the HashSet.
• remove(key) — Removes the value key from the HashSet. If key does not exist, do nothing.
• contains(key) — Returns true if key exists, false otherwise.

Example 1: Input: ["MyHashSet","add","add","contains","contains","add","contains","remove","contains"] [[], [1], [2], [1], [3], [2], [2], [2], [2]] Output: [null, null, null, true, false, null, true, null, false]

Constraints:

• 0 <= key <= 10^6
• At most 10^4 calls will be made to add, remove, and contains.

Prerequisites

Before attempting this problem, you should be comfortable with:

• Arrays — direct-address tables using index-as-key
• Hash Functions — mapping keys to array indices
• Linked Lists — chaining to handle collisions

1. Boolean Array (Direct Address Table)

Intuition

Since keys are bounded between 0 and 10^6, we can allocate a boolean array of size 10^6 + 1. Each index represents a key — True means the key is present, False means it is absent. No hashing or collision handling needed because the key directly serves as the index.

This is a direct-address table — extremely fast (O(1) per operation) but only practical when the key range is small and known in advance.

Algorithm

• add(key): Set data[key] = True.
• remove(key): Set data[key] = False.
• contains(key): Return data[key].

Solution

class MyHashSet:
    def __init__(self):
        self.data = [False] * (10**6 + 1)

    def add(self, key: int) -> None:
        self.data[key] = True

    def remove(self, key: int) -> None:
        self.data[key] = False

    def contains(self, key: int) -> bool:
        return self.data[key]


hs = MyHashSet()
hs.add(1)
hs.add(2)
print(hs.contains(1))   # True
print(hs.contains(3))   # False
hs.add(2)
print(hs.contains(2))   # True
hs.remove(2)
print(hs.contains(2))   # False

Complexity

• Time: O(1) per operation
• Space: O(N) where N = 10^6 — fixed overhead regardless of how many keys are inserted

2. Chaining with Array of Lists

Intuition

A more realistic hash set uses a hash function to map keys into buckets, and each bucket is a list (chain) that can hold multiple keys. Collisions — when two keys hash to the same bucket — are resolved by storing both in the same list and searching linearly within it.

This approach generalises to arbitrary key types and does not require knowing the key range upfront. The key design choices are: the number of buckets (affects collision rate) and the hash function.

Algorithm

• __init__: Create NUM_BUCKETS empty lists.
• _hash(key): Return key % NUM_BUCKETS to pick the bucket.
• add(key): If key not already in the bucket, append it.
• remove(key): Filter key out of the bucket list.
• contains(key): Return True if key is in the bucket.

flowchart LR
    K["key=1007"] --> H["hash = 1007 % 1000 = 7"]
    H --> B["bucket[7]  →  [7, 1007]"]
    B --> C["search list for 1007  →  found!"]

Solution

class MyHashSet:
    NUM_BUCKETS = 1000

    def __init__(self):
        self.buckets = [[] for _ in range(self.NUM_BUCKETS)]

    def _hash(self, key: int) -> int:
        return key % self.NUM_BUCKETS

    def add(self, key: int) -> None:
        h = self._hash(key)
        if key not in self.buckets[h]:
            self.buckets[h].append(key)

    def remove(self, key: int) -> None:
        h = self._hash(key)
        self.buckets[h] = [k for k in self.buckets[h] if k != key]

    def contains(self, key: int) -> bool:
        h = self._hash(key)
        return key in self.buckets[h]


hs = MyHashSet()
hs.add(1)
hs.add(2)
print(hs.contains(1))   # True
print(hs.contains(3))   # False
hs.add(2)
print(hs.contains(2))   # True
hs.remove(2)
print(hs.contains(2))   # False

Complexity

• Time: O(n / k) per operation on average, where n is the number of keys and k is the number of buckets. With a good hash and reasonable load, this approaches O(1).
• Space: O(n + k) — k bucket lists plus space for n stored keys

Common Pitfalls

Not checking for duplicates before adding. add should be idempotent — adding a key that already exists should not create a duplicate entry in the bucket. Always check if key not in bucket before appending.

Modifying the bucket list while iterating it. When removing, create a new filtered list rather than deleting elements while iterating. In Python, a list comprehension is the cleanest way to do this.

Choosing too few buckets. With only 10 buckets and 10^4 operations, each bucket could hold 1000 keys on average, making each operation O(1000). Choose a bucket count that gives a low load factor (roughly number-of-keys / number-of-buckets ≈ 1).

Design HashMap

Difficulty: Easy Source: NeetCode

Problem

Design a HashMap without using any built-in hash table libraries.

Implement the MyHashMap class:

• put(key, value) — Inserts or updates the mapping key → value. If key already exists, update its value.
• get(key) — Returns the value mapped to key, or -1 if it does not exist.
• remove(key) — Removes key and its associated value. If key does not exist, do nothing.

Example 1: Input: ["MyHashMap","put","put","get","get","put","get","remove","get"] [[], [1,1], [2,2], [1], [3], [2,1], [2], [2], [2]] Output: [null, null, null, 1, -1, null, 1, null, -1]

Constraints:

• 0 <= key, value <= 10^6
• At most 10^4 calls will be made to put, get, and remove.

Prerequisites

Before attempting this problem, you should be comfortable with:

• Arrays — fixed-size storage for direct address tables
• Hash Functions — mapping keys to indices
• Linked Lists or Arrays — chaining to handle collisions

1. Fixed-Size Array (Direct Address Table)

Intuition

Since keys are bounded between 0 and 10^6, allocate an array of size 10^6 + 1 where each slot stores the associated value (or -1 to indicate absence). The key directly serves as the array index — no hash function needed. This is fast but memory-heavy.

Algorithm

• __init__: Create data = [-1] * (10^6 + 1).
• put(key, value): Set data[key] = value.
• get(key): Return data[key].
• remove(key): Set data[key] = -1.

Solution

class MyHashMap:
    def __init__(self):
        self.data = [-1] * (10**6 + 1)

    def put(self, key: int, value: int) -> None:
        self.data[key] = value

    def get(self, key: int) -> int:
        return self.data[key]

    def remove(self, key: int) -> None:
        self.data[key] = -1


hm = MyHashMap()
hm.put(1, 1)
hm.put(2, 2)
print(hm.get(1))    # 1
print(hm.get(3))    # -1
hm.put(2, 1)        # update key 2
print(hm.get(2))    # 1
hm.remove(2)
print(hm.get(2))    # -1

Complexity

• Time: O(1) per operation
• Space: O(N) where N = 10^6 — allocated upfront regardless of usage

2. Chaining with Buckets

Intuition

A more realistic implementation uses a hash function to assign keys to buckets, with each bucket holding a list of (key, value) pairs. On collision, pairs are stored in the same bucket and we search linearly for the matching key. This scales better in memory when the key space is large.

Algorithm

• __init__: Create NUM_BUCKETS empty lists.
• _hash(key): Return key % NUM_BUCKETS.
• put(key, value): Search the bucket for key. If found, update value. Otherwise, append (key, value).
• get(key): Search the bucket for key. Return its value or -1.
• remove(key): Filter out the pair with key from the bucket.

flowchart LR
    P1["put(1, 1)"] --> B1["hash=1  bucket[1] = [(1,1)]"]
    P2["put(1001, 5)"] --> B2["hash=1  bucket[1] = [(1,1),(1001,5)]"]
    G["get(1001)"] --> S["search bucket[1] for key=1001  →  found  →  return 5"]

Solution

class MyHashMap:
    NUM_BUCKETS = 1000

    def __init__(self):
        self.buckets = [[] for _ in range(self.NUM_BUCKETS)]

    def _hash(self, key: int) -> int:
        return key % self.NUM_BUCKETS

    def put(self, key: int, value: int) -> None:
        h = self._hash(key)
        for i, (k, v) in enumerate(self.buckets[h]):
            if k == key:
                self.buckets[h][i] = (key, value)
                return
        self.buckets[h].append((key, value))

    def get(self, key: int) -> int:
        h = self._hash(key)
        for k, v in self.buckets[h]:
            if k == key:
                return v
        return -1

    def remove(self, key: int) -> None:
        h = self._hash(key)
        self.buckets[h] = [(k, v) for k, v in self.buckets[h] if k != key]


hm = MyHashMap()
hm.put(1, 1)
hm.put(2, 2)
print(hm.get(1))    # 1
print(hm.get(3))    # -1
hm.put(2, 1)        # update key 2
print(hm.get(2))    # 1
hm.remove(2)
print(hm.get(2))    # -1

Complexity

• Time: O(n / k) per operation on average, where n is the number of stored pairs and k is the number of buckets
• Space: O(n + k)

Common Pitfalls

Updating instead of appending on duplicate keys. put must update the value for an existing key, not append a second (key, value) pair. Iterate through the bucket first; if the key is found, update in place and return early.

Returning -1 for absent keys vs. None. The problem specifies -1 as the sentinel for “not found.” If you use a different sentinel, you risk confusing a legitimately stored value of -1 with “not found.” For this problem, the constraints say 0 <= value <= 10^6, so -1 is safe. In a general-purpose map, use None instead.

Thread safety. Real hash map implementations need locking or lock-free data structures for concurrent access. For this problem, assume single-threaded access.

Sort an Array

Difficulty: Medium Source: NeetCode

Problem

Given an array of integers nums, sort the array in ascending order and return it.

You must solve the problem without using any built-in functions in O(n log n) time complexity and with the smallest space complexity possible.

Example 1: Input: nums = [5, 2, 3, 1] Output: [1, 2, 3, 5]

Example 2: Input: nums = [5, 1, 1, 2, 0, 0] Output: [0, 0, 1, 1, 2, 5]

Constraints:

• 1 <= nums.length <= 5 * 10^4
• -5 * 10^4 <= nums[i] <= 5 * 10^4

Prerequisites

Before attempting this problem, you should be comfortable with:

• Recursion — divide-and-conquer thinking
• Merging sorted arrays — combining two sorted halves into one

1. Brute Force (Bubble Sort)

Intuition

Repeatedly scan through the array and swap adjacent elements that are out of order. Each full pass “bubbles” the largest unsorted element to its final position at the end. After n - 1 passes, the array is sorted. This is correct but extremely slow for large inputs.

Algorithm

1. For each pass i from 0 to n - 1:
   • For each index j from 0 to n - i - 2:
     • If nums[j] > nums[j + 1], swap them.
2. Return nums.

Solution

def sortArray(nums):
    n = len(nums)
    for i in range(n):
        for j in range(n - i - 1):
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
    return nums


print(sortArray([5, 2, 3, 1]))       # [1, 2, 3, 5]
print(sortArray([5, 1, 1, 2, 0, 0])) # [0, 0, 1, 1, 2, 5]

Complexity

• Time: O(n²)
• Space: O(1)

2. Merge Sort

Intuition

Merge sort is a classic divide-and-conquer algorithm. Split the array in half, recursively sort each half, then merge the two sorted halves back together. The merge step is O(n) and the recursion depth is O(log n), giving an overall time of O(n log n).

The key operation is the merge: two sorted arrays can be combined in O(n) by always picking the smaller front element from either array.

Algorithm

1. Base case: If the array has 0 or 1 elements, it is already sorted — return it.
2. Split: Find the midpoint mid = len(nums) // 2. Recursively sort left = nums[:mid] and right = nums[mid:].
3. Merge: Compare elements from the front of left and right, appending the smaller one to the result.
4. Drain any remaining elements from either half.
5. Return the merged result.

flowchart TD
    A["[5, 2, 3, 1]"]
    A --> B["[5, 2]"]
    A --> C["[3, 1]"]
    B --> D["[5]"]
    B --> E["[2]"]
    C --> F["[3]"]
    C --> G["[1]"]
    D & E --> H["merge → [2, 5]"]
    F & G --> I["merge → [1, 3]"]
    H & I --> J["merge → [1, 2, 3, 5]"]

Solution

def sortArray(nums):
    if len(nums) <= 1:
        return nums

    mid = len(nums) // 2
    left = sortArray(nums[:mid])
    right = sortArray(nums[mid:])

    # Merge step
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result


print(sortArray([5, 2, 3, 1]))        # [1, 2, 3, 5]
print(sortArray([5, 1, 1, 2, 0, 0]))  # [0, 0, 1, 1, 2, 5]
print(sortArray([-4, 0, 7, 4, 9, -5, 1, 10, -1, -1]))  # [-5,-4,-1,-1,0,1,4,7,9,10]

Complexity

• Time: O(n log n) — log n levels of recursion, each doing O(n) work in the merge step
• Space: O(n) — temporary arrays allocated during the merge steps; O(log n) for the call stack

Common Pitfalls

Mutating nums in-place during merge sort. The version above creates new lists during merging, which is simpler but uses more memory. An in-place merge sort is significantly more complex — for interviews, the slicing approach shown here is preferred.

Choosing the wrong pivot for quicksort. If you use quicksort instead of merge sort, always-worst-case pivot selection (e.g., always picking the first element on a sorted array) degrades to O(n²). Merge sort avoids this problem entirely — its worst case is always O(n log n).

Stack overflow on very large inputs. Python’s default recursion limit is 1000. For n = 50000, the recursion depth of merge sort is about log₂(50000) ≈ 16 — well within limits. No issue here, but keep this in mind for other recursive algorithms.

Sort Colors

Difficulty: Medium Source: NeetCode

Problem

Given an array nums with n objects colored red, white, or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white, and blue.

We will use the integers 0, 1, and 2 to represent the colors red, white, and blue, respectively.

You must solve this problem without using the library’s sort function.

Example 1: Input: nums = [2, 0, 2, 1, 1, 0] Output: [0, 0, 1, 1, 2, 2]

Example 2: Input: nums = [2, 0, 1] Output: [0, 1, 2]

Constraints:

• n == nums.length
• 1 <= n <= 300
• nums[i] is either 0, 1, or 2.

Prerequisites

Before attempting this problem, you should be comfortable with:

• Two Pointers — maintaining multiple indices into an array
• In-place swapping — rearranging elements without extra storage

1. Brute Force (Count and Overwrite)

Intuition

Count how many 0s, 1s, and 2s appear in the array. Then overwrite the array — first fill in all the 0s, then all the 1s, then all the 2s. This takes two passes and constant extra space (just three counters). Simple and easy to verify.

Algorithm

1. Count occurrences of 0, 1, 2.
2. Overwrite nums: first count[0] positions get 0, next count[1] positions get 1, rest get 2.

Solution

def sortColors(nums):
    count = [0, 0, 0]
    for num in nums:
        count[num] += 1
    i = 0
    for color in range(3):
        for _ in range(count[color]):
            nums[i] = color
            i += 1


nums = [2, 0, 2, 1, 1, 0]
sortColors(nums)
print(nums)  # [0, 0, 1, 1, 2, 2]

nums = [2, 0, 1]
sortColors(nums)
print(nums)  # [0, 1, 2]

Complexity

• Time: O(n) — two passes
• Space: O(1) — three counters

2. Dutch National Flag Algorithm

Intuition

This is the classic Dutch National Flag problem (named after the three-color Dutch flag) attributed to Edsger Dijkstra. The idea is to use three pointers:

• low — everything left of low is 0
• mid — the current element being examined
• high — everything right of high is 2
• Elements between low and high (exclusive) are either 1 or unprocessed

We scan mid from left to right. Depending on the value at mid:

• If it is 0, swap it to the low zone and advance both low and mid.
• If it is 1, it is already in the middle — just advance mid.
• If it is 2, swap it to the high zone and retreat high. Do not advance mid yet because the swapped-in element has not been examined.

This sorts the array in a single pass with no extra memory.

Algorithm

1. Initialize low = 0, mid = 0, high = n - 1.
2. While mid <= high:
   • If nums[mid] == 0: swap nums[mid] and nums[low], increment low and mid.
   • If nums[mid] == 1: increment mid.
   • If nums[mid] == 2: swap nums[mid] and nums[high], decrement high.

flowchart LR
    S(["[2,0,2,1,1,0]  low=0 mid=0 high=5"])
    S --> a["nums[0]=2  →  swap with high  →  [0,0,2,1,1,2]  high=4"]
    a --> b["nums[0]=0  →  swap with low  →  already placed  low=1 mid=1"]
    b --> c["nums[1]=0  →  swap with low  →  low=2 mid=2"]
    c --> d["nums[2]=2  →  swap with high  →  [0,0,1,1,2,2]  high=3"]
    d --> e["nums[2]=1  →  mid=3"]
    e --> f["nums[3]=1  →  mid=4  →  mid>high  →  done"]
    f --> R(["[0,0,1,1,2,2]"])

Solution

def sortColors(nums):
    low, mid, high = 0, 0, len(nums) - 1
    while mid <= high:
        if nums[mid] == 0:
            nums[low], nums[mid] = nums[mid], nums[low]
            low += 1
            mid += 1
        elif nums[mid] == 1:
            mid += 1
        else:  # nums[mid] == 2
            nums[mid], nums[high] = nums[high], nums[mid]
            high -= 1


nums = [2, 0, 2, 1, 1, 0]
sortColors(nums)
print(nums)  # [0, 0, 1, 1, 2, 2]

nums = [2, 0, 1]
sortColors(nums)
print(nums)  # [0, 1, 2]

nums = [1]
sortColors(nums)
print(nums)  # [1]

Complexity

• Time: O(n) — single pass, mid advances or high retreats every iteration
• Space: O(1) — three pointer variables only

Common Pitfalls

Not advancing mid when swapping with high. After swapping nums[mid] with nums[high], you decrement high but do NOT increment mid. The element that just arrived at mid from high has not been examined yet — it could be 0, 1, or 2. Advancing mid prematurely would skip it.

Confusing low and mid. After swapping nums[mid] with nums[low], it is safe to advance both because the element that moved to low’s position is guaranteed to be 0 (by invariant — everything before low is already 0), and the element that moved to mid from low was previously known to be 0 or 1 (never 2), so advancing mid is safe.

Top K Frequent Elements

Difficulty: Medium Source: NeetCode

Problem

Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order.

Example 1: Input: nums = [1, 1, 1, 2, 2, 3], k = 2 Output: [1, 2]

Example 2: Input: nums = [1], k = 1 Output: [1]

Constraints:

• 1 <= nums.length <= 10^5
• -10^4 <= nums[i] <= 10^4
• k is in the range [1, the number of unique elements in nums]
• The answer is unique (no ties for the k-th position).

Prerequisites

Before attempting this problem, you should be comfortable with:

• Hash Maps — counting element frequencies
• Sorting — ordering by a custom key
• Bucket Sort — mapping values to indices representing frequency

1. Hash Map + Sort

Intuition

Count the frequency of every element with a hash map, then sort the unique elements by their frequency in descending order and return the first k. Straightforward and easy to implement — the bottleneck is the sort.

Algorithm

1. Build a frequency map count.
2. Sort the unique keys by frequency descending.
3. Return the first k keys.

Solution

def topKFrequent(nums, k):
    count = {}
    for num in nums:
        count[num] = count.get(num, 0) + 1
    # Sort by frequency descending
    sorted_keys = sorted(count.keys(), key=lambda x: count[x], reverse=True)
    return sorted_keys[:k]


print(topKFrequent([1, 1, 1, 2, 2, 3], 2))   # [1, 2]
print(topKFrequent([1], 1))                   # [1]
print(topKFrequent([4, 1, -1, 2, -1, 2, 3], 2))  # [-1, 2]

Complexity

• Time: O(n log n) — dominated by the sort of up to n unique elements
• Space: O(n) — the frequency map

2. Bucket Sort

Intuition

Here is the key observation: the maximum possible frequency of any element is n (if all elements are the same). So we can create a list of n + 1 buckets where bucket[f] holds all elements that appear exactly f times.

After filling the buckets, scan from the highest frequency down to 1, collecting elements until we have k. This avoids sorting entirely — the “sort” is implicit in the bucket indices.

Algorithm

1. Build frequency map count.
2. Create buckets of size n + 1, where buckets[f] is a list.
3. For each (num, freq) in count, append num to buckets[freq].
4. Scan buckets from index n down to 1, collecting elements into the result until we have k.

flowchart LR
    A(["nums=[1,1,1,2,2,3]"])
    A --> B["count: {1:3, 2:2, 3:1}"]
    B --> C["buckets[1]=[3]  buckets[2]=[2]  buckets[3]=[1]"]
    C --> D["scan from high: take from [3] → [1] → done when k=2"]
    D --> E(["result=[1,2]"])

Solution

def topKFrequent(nums, k):
    count = {}
    for num in nums:
        count[num] = count.get(num, 0) + 1

    # buckets[i] holds all numbers with frequency i
    buckets = [[] for _ in range(len(nums) + 1)]
    for num, freq in count.items():
        buckets[freq].append(num)

    result = []
    for freq in range(len(buckets) - 1, 0, -1):
        for num in buckets[freq]:
            result.append(num)
            if len(result) == k:
                return result
    return result


print(topKFrequent([1, 1, 1, 2, 2, 3], 2))      # [1, 2]
print(topKFrequent([1], 1))                      # [1]
print(topKFrequent([4, 1, -1, 2, -1, 2, 3], 2)) # [-1, 2]

Complexity

• Time: O(n) — building the count map is O(n), filling the buckets is O(n), scanning the buckets is O(n)
• Space: O(n) — the count map and bucket list each hold at most n entries

Common Pitfalls

Confusing frequency with value. The bucket index represents frequency, not the element value. buckets[3] holds elements that appear 3 times, not the number 3.

Allocating n + 1 buckets. The maximum possible frequency is n (all elements identical), so you need indices 0 through n. Allocate n + 1 slots. Index 0 is never used but that is fine.

Returning early. Once you have collected k elements, you can return immediately. There is no need to scan the remaining buckets.

Encode and Decode Strings

Difficulty: Medium Source: NeetCode

Problem

Design an algorithm to encode a list of strings to a single string. The encoded string is then sent over the network and is decoded back to the original list of strings.

Implement the encode and decode functions:

• encode(strs) — encodes a list of strings into a single string.
• decode(s) — decodes the encoded string back into the original list of strings.

The encoded string should be decodable even if the individual strings contain any possible character, including the delimiter character itself.

Example 1: Input: ["lint", "code", "love", "you"] Output: ["lint", "code", "love", "you"] (after encode then decode)

Example 2: Input: ["we", "say", ":", "yes"] Output: ["we", "say", ":", "yes"]

Constraints:

• 0 <= strs.length <= 200
• 0 <= strs[i].length <= 200
• strs[i] contains any possible characters out of 256 valid ASCII characters.

Prerequisites

Before attempting this problem, you should be comfortable with:

• Strings — slicing, concatenation, and find/index operations
• Framing / length-prefix encoding — a technique from network protocols for delimiting variable-length messages

1. Naive Delimiter (Broken Approach)

Intuition

A first instinct is to join strings with a special delimiter like # or | and split on it during decoding. This fails when strings themselves contain the delimiter — there is no way to distinguish a delimiter from a literal character in the string.

This approach is shown here only to illustrate why it breaks, not as a solution.

# BROKEN — fails if any string contains the delimiter
def encode_broken(strs):
    return "#".join(strs)

def decode_broken(s):
    return s.split("#")

# Works fine here...
print(decode_broken(encode_broken(["lint", "code"])))   # ['lint', 'code']

# But breaks when a string contains '#'
print(decode_broken(encode_broken(["a#b", "c"])))   # ['a', 'b', 'c']  ← WRONG

2. Length-Prefix Encoding

Intuition

The trick is to encode the length of each string along with the string itself, separated by a special character. This way, during decoding, you always know exactly how many characters to read — you do not need to search for a delimiter at all.

The format is: "<length>#<string>" repeated for each string. For example:

• ["lint", "code", "love", "you"] → "4#lint4#code4#love3#you"
• ["we", "say", ":", "yes"] → "2#we3#say1#:3#yes"

The # here is just used to separate the length digits from the string content. Even if the string itself contains #, we are safe because we read exactly length characters after the #, never searching for another #.

Algorithm

Encode:

1. For each string s, append f"{len(s)}#{s}" to the result.
2. Return the concatenated result.

Decode:

1. Start with pointer i = 0.
2. While i < len(s):
   • Find the next # starting from i. Its index is j.
   • Read the length: length = int(s[i:j]).
   • Read the string: s[j+1 : j+1+length].
   • Advance i to j + 1 + length.
3. Return collected strings.

flowchart LR
    E(["encode(['lint','code'])"]) --> S["'4#lint4#code'"]
    S --> D["i=0  →  j=1  →  len=4  →  read 'lint'  →  i=6"]
    D --> D2["i=6  →  j=7  →  len=4  →  read 'code'  →  i=12"]
    D2 --> R(["['lint','code']"])

Solution

def encode(strs):
    result = ""
    for s in strs:
        result += f"{len(s)}#{s}"
    return result


def decode(s):
    result = []
    i = 0
    while i < len(s):
        j = s.index('#', i)            # find the next '#' from position i
        length = int(s[i:j])           # parse the length
        result.append(s[j + 1: j + 1 + length])  # read exactly 'length' chars
        i = j + 1 + length             # advance past the string
    return result


# Test 1: basic
strs = ["lint", "code", "love", "you"]
print(decode(encode(strs)))            # ['lint', 'code', 'love', 'you']

# Test 2: strings containing '#'
strs = ["we", "say", ":", "yes"]
print(decode(encode(strs)))            # ['we', 'say', ':', 'yes']

# Test 3: empty string in the list
strs = ["", "hello", ""]
print(decode(encode(strs)))            # ['', 'hello', '']

Complexity

• Time: O(n) for both encode and decode, where n is the total number of characters across all strings
• Space: O(n) — the encoded string and the output list

Common Pitfalls

Searching for # naively. During decoding, do not scan for the # from position 0 on every iteration — start from the current pointer i. Also, s.index('#', i) is safe because the # is always at position i + (number of digits), which is known to be present.

Forgetting multi-digit lengths. If a string has length 200, the prefix is "200#" — three digits, not one. The s.index('#', i) approach handles this correctly regardless of how many digits the length has.

Empty list edge case. If strs = [], encode([]) returns "". decode("") starts with i = 0 and the while i < len(s) condition is immediately false, returning []. This is correct behaviour.

Range Sum Query 2D - Immutable

Difficulty: Medium Source: NeetCode

Problem

Given a 2D matrix matrix, handle multiple queries of the following type:

• sumRegion(row1, col1, row2, col2) — Calculate the sum of the elements of matrix inside the rectangle defined by its upper left corner (row1, col1) and lower right corner (row2, col2).

Implement the NumMatrix class with an efficient sumRegion method.

Example 1: Input: matrix = [[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]] sumRegion(2,1,4,3) → 8 sumRegion(1,1,2,2) → 11 sumRegion(1,2,2,4) → 12

Constraints:

• m == matrix.length, n == matrix[i].length
• 1 <= m, n <= 200
• -10^4 <= matrix[i][j] <= 10^4
• 0 <= row1 <= row2 < m
• 0 <= col1 <= col2 < n
• At most 10^4 calls to sumRegion.

Prerequisites

Before attempting this problem, you should be comfortable with:

• Prefix sums (1D) — computing cumulative sums for range queries
• 2D arrays — indexing and iteration over rows and columns

1. Brute Force (Iterate Rectangle)

Intuition

For each query, loop over every cell in the specified rectangle and add up the values. Simple and correct, but redoes work for every query — with 10^4 queries over a 200 × 200 matrix, this performs up to 4 × 10^8 operations.

Algorithm

• __init__: Store the matrix.
• sumRegion: Iterate row from row1 to row2, col from col1 to col2, summing matrix[row][col].

Solution

class NumMatrix:
    def __init__(self, matrix):
        self.matrix = matrix

    def sumRegion(self, row1, col1, row2, col2):
        total = 0
        for r in range(row1, row2 + 1):
            for c in range(col1, col2 + 1):
                total += self.matrix[r][c]
        return total


matrix = [
    [3, 0, 1, 4, 2],
    [5, 6, 3, 2, 1],
    [1, 2, 0, 1, 5],
    [4, 1, 0, 1, 7],
    [1, 0, 3, 0, 5],
]
nm = NumMatrix(matrix)
print(nm.sumRegion(2, 1, 4, 3))   # 8
print(nm.sumRegion(1, 1, 2, 2))   # 11
print(nm.sumRegion(1, 2, 2, 4))   # 12

Complexity

• Time: O(m * n) per query
• Space: O(1) extra

2. 2D Prefix Sum

Intuition

Precompute a 2D prefix sum table prefix where prefix[r][c] = sum of all elements in the rectangle from (0, 0) to (r-1, c-1) (using 1-indexed prefix to simplify boundary handling).

Then any rectangle sum can be computed with four lookups using the inclusion-exclusion principle:

sumRegion(r1, c1, r2, c2)
  = prefix[r2+1][c2+1]
  - prefix[r1][c2+1]
  - prefix[r2+1][c1]
  + prefix[r1][c1]

Think of it like adding and subtracting overlapping areas:

+------------------+
|   A   |    B    |
|-------+---------|
|   C   |  query  |
+------------------+

sum(query) = total - A - C + corner(A∩C was subtracted twice)

Algorithm

__init__:

1. Create prefix of size (m+1) × (n+1) filled with zeros.
2. For each r from 1 to m, for each c from 1 to n:
   • prefix[r][c] = matrix[r-1][c-1] + prefix[r-1][c] + prefix[r][c-1] - prefix[r-1][c-1]

sumRegion(r1, c1, r2, c2):

1. Return prefix[r2+1][c2+1] - prefix[r1][c2+1] - prefix[r2+1][c1] + prefix[r1][c1]

flowchart LR
    A(["Precompute prefix[r][c]  O(m*n)"])
    A --> B(["Each sumRegion query  O(1)"])
    B --> C["prefix[r2+1][c2+1] - prefix[r1][c2+1] - prefix[r2+1][c1] + prefix[r1][c1]"]

Solution

class NumMatrix:
    def __init__(self, matrix):
        m, n = len(matrix), len(matrix[0])
        # prefix[r][c] = sum of matrix[0..r-1][0..c-1]
        self.prefix = [[0] * (n + 1) for _ in range(m + 1)]
        for r in range(1, m + 1):
            for c in range(1, n + 1):
                self.prefix[r][c] = (
                    matrix[r - 1][c - 1]
                    + self.prefix[r - 1][c]
                    + self.prefix[r][c - 1]
                    - self.prefix[r - 1][c - 1]
                )

    def sumRegion(self, row1, col1, row2, col2):
        p = self.prefix
        return (
            p[row2 + 1][col2 + 1]
            - p[row1][col2 + 1]
            - p[row2 + 1][col1]
            + p[row1][col1]
        )


matrix = [
    [3, 0, 1, 4, 2],
    [5, 6, 3, 2, 1],
    [1, 2, 0, 1, 5],
    [4, 1, 0, 1, 7],
    [1, 0, 3, 0, 5],
]
nm = NumMatrix(matrix)
print(nm.sumRegion(2, 1, 4, 3))   # 8
print(nm.sumRegion(1, 1, 2, 2))   # 11
print(nm.sumRegion(1, 2, 2, 4))   # 12

Complexity

• Time: O(m * n) for preprocessing; O(1) per sumRegion query
• Space: O(m * n) — the prefix table

Common Pitfalls

Off-by-one indexing. Using a (m+1) × (n+1) prefix table with 1-based indexing means prefix[0][...] and prefix[...][0] are always 0 — which acts as a safe boundary, eliminating the need for explicit bounds checks.

Getting the inclusion-exclusion formula backwards. Draw it out: to get the sum of a rectangle, start with the large prefix sum at the bottom-right, subtract the strips above and to the left, then add back the corner that was subtracted twice.

Negative values. The matrix allows negative values — but the prefix sum approach handles this correctly with no modifications. Do not short-circuit on negative values.

Product of Array Except Self

Difficulty: Medium Source: NeetCode

Problem

Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i].

The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.

You must write an algorithm that runs in O(n) time and without using the division operation.

Example 1: Input: nums = [1, 2, 3, 4] Output: [24, 12, 8, 6]

Example 2: Input: nums = [-1, 1, 0, -3, 3] Output: [0, 0, 9, 0, 0]

Constraints:

• 2 <= nums.length <= 10^5
• -30 <= nums[i] <= 30
• The product of any prefix or suffix fits in a 32-bit integer.

Prerequisites

Before attempting this problem, you should be comfortable with:

• Prefix products — cumulative products from the left
• Suffix products — cumulative products from the right
• Two-pass array traversal — scanning left-to-right then right-to-left

1. Brute Force

Intuition

For each position i, multiply together all elements except nums[i]. Two nested loops: the outer loop picks the position to exclude, the inner loop multiplies everything else.

Algorithm

1. For each index i:
   • Set product = 1.
   • For each index j, if j != i, multiply product *= nums[j].
   • Set answer[i] = product.
2. Return answer.

Solution

def productExceptSelf(nums):
    n = len(nums)
    answer = [1] * n
    for i in range(n):
        for j in range(n):
            if j != i:
                answer[i] *= nums[j]
    return answer


print(productExceptSelf([1, 2, 3, 4]))         # [24, 12, 8, 6]
print(productExceptSelf([-1, 1, 0, -3, 3]))    # [0, 0, 9, 0, 0]

Complexity

• Time: O(n²)
• Space: O(1) extra (not counting the output array)

2. Prefix and Suffix Products

Intuition

For any index i, the product of all elements except nums[i] equals:

• (product of all elements to the left of i) × (product of all elements to the right of i)

We can compute these two separately:

• Left pass: Build a prefix array where prefix[i] = product of nums[0..i-1].
• Right pass: Build a suffix array where suffix[i] = product of nums[i+1..n-1].
• answer[i] = prefix[i] * suffix[i].

We can do this in O(1) extra space (beyond the output array) by computing prefix on the first pass, then multiplying in suffix on the second pass directly into the answer array.

Algorithm

1. Initialise answer = [1] * n.
2. Left pass: Maintain a running prefix = 1. For each i, set answer[i] = prefix, then update prefix *= nums[i].
3. Right pass: Maintain a running suffix = 1. For each i from right to left, multiply answer[i] *= suffix, then update suffix *= nums[i].
4. Return answer.

flowchart LR
    A(["nums = [1, 2, 3, 4]"])
    A --> B["Left pass: answer = [1, 1, 2, 6]"]
    B --> C["Right pass (suffix): answer = [24, 12, 8, 6]"]
    C --> R(["return [24, 12, 8, 6]"])

Solution

def productExceptSelf(nums):
    n = len(nums)
    answer = [1] * n

    # Left pass: answer[i] = product of nums[0..i-1]
    prefix = 1
    for i in range(n):
        answer[i] = prefix
        prefix *= nums[i]

    # Right pass: multiply in product of nums[i+1..n-1]
    suffix = 1
    for i in range(n - 1, -1, -1):
        answer[i] *= suffix
        suffix *= nums[i]

    return answer


print(productExceptSelf([1, 2, 3, 4]))          # [24, 12, 8, 6]
print(productExceptSelf([-1, 1, 0, -3, 3]))     # [0, 0, 9, 0, 0]
print(productExceptSelf([2, 3]))                 # [3, 2]

Complexity

• Time: O(n) — two passes
• Space: O(1) extra (the output array does not count toward space complexity per the problem statement)

Common Pitfalls

Using division. The naive O(n) approach — compute total product, divide by nums[i] — is explicitly prohibited and also breaks when nums[i] == 0.

The zero case. The prefix/suffix approach handles zeros automatically. If nums[i] == 0, both its left prefix and right suffix are unaffected. The zero propagates through multiplication correctly — no special casing needed.

Order of operations in the right pass. In the right pass, multiply the current answer[i] by suffix BEFORE updating suffix. If you update suffix *= nums[i] first, you include nums[i] in the suffix for position i, which is wrong — we want the product of elements strictly to the right.

Valid Sudoku

Difficulty: Medium Source: NeetCode

Problem

Determine if a 9 × 9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules:

1. Each row must contain the digits 1–9 with no repetition.
2. Each column must contain the digits 1–9 with no repetition.
3. Each of the nine 3 × 3 sub-boxes must contain the digits 1–9 with no repetition.

Note: A Sudoku board does not need to be solvable to be valid. Only already-filled cells are validated. Empty cells are represented by '.'.

Example 1: Input: a standard partially-filled Sudoku board Output: true

Example 2: Input: a board with 8 appearing twice in the top row Output: false

Constraints:

• board.length == 9
• board[i].length == 9
• board[i][j] is a digit 1–9 or '.'.

Prerequisites

Before attempting this problem, you should be comfortable with:

• Hash Sets — detecting duplicates efficiently
• 2D array indexing — mapping (row, col) to box index
• String vs integer handling — board cells are strings '1'–'9' and '.'

1. Three Separate Passes

Intuition

Validate each constraint independently: check all rows for duplicates, then check all columns, then check all 3×3 boxes. Each check uses a set to detect repeated digits. Although this is three passes, it is still O(81) = O(1) since the board is a fixed 9×9 grid.

Algorithm

1. For each of 9 rows: collect non-'.' cells into a list; return false if any duplicates.
2. For each of 9 columns: same check.
3. For each of 9 boxes (indexed by box_row 0–2, box_col 0–2): collect the 9 cells in each 3×3 block; return false if any duplicates.
4. Return true.

Solution

def isValidSudoku(board):
    # Check rows
    for row in board:
        seen = set()
        for c in row:
            if c == '.':
                continue
            if c in seen:
                return False
            seen.add(c)

    # Check columns
    for col in range(9):
        seen = set()
        for row in range(9):
            c = board[row][col]
            if c == '.':
                continue
            if c in seen:
                return False
            seen.add(c)

    # Check 3x3 boxes
    for box_row in range(3):
        for box_col in range(3):
            seen = set()
            for r in range(3):
                for c in range(3):
                    val = board[box_row * 3 + r][box_col * 3 + c]
                    if val == '.':
                        continue
                    if val in seen:
                        return False
                    seen.add(val)

    return True


board = [
    ["5","3",".",".","7",".",".",".","."],
    ["6",".",".","1","9","5",".",".","."],
    [".","9","8",".",".",".",".","6","."],
    ["8",".",".",".","6",".",".",".","3"],
    ["4",".",".","8",".","3",".",".","1"],
    ["7",".",".",".","2",".",".",".","6"],
    [".","6",".",".",".",".","2","8","."],
    [".",".",".","4","1","9",".",".","5"],
    [".",".",".",".","8",".",".","7","9"],
]
print(isValidSudoku(board))  # True

invalid_board = [row[:] for row in board]
invalid_board[0][1] = "5"   # duplicate '5' in first row
print(isValidSudoku(invalid_board))  # False

Complexity

• Time: O(81) = O(1) — fixed board size
• Space: O(9) = O(1) — at most 9 elements in any set at once

2. Single Pass with Keyed Sets

Intuition

Instead of three separate loops, visit each cell once and simultaneously check all three constraints using one set per constraint type. The key insight is encoding the constraint identity into the set entry itself:

• Row check: store (row, digit) in a rows set
• Column check: store (col, digit) in a cols set
• Box check: store (row // 3, col // 3, digit) in a boxes set

If any of these tuples is already in its respective set, return false immediately.

Algorithm

1. Create three empty sets: rows, cols, boxes.
2. For each cell (r, c) with value val:
   • Skip if val == '.'.
   • If (r, val) in rows or (c, val) in cols or (r//3, c//3, val) in boxes: return false.
   • Add the tuples to each set.
3. Return true.

flowchart LR
    A(["visit cell (0,0) val='5'"])
    A --> B["check rows: (0,'5') — not seen"]
    B --> C["check cols: (0,'5') — not seen"]
    C --> D["check boxes: (0,0,'5') — not seen"]
    D --> E["add all three tuples, continue"]

Solution

def isValidSudoku(board):
    rows = set()
    cols = set()
    boxes = set()

    for r in range(9):
        for c in range(9):
            val = board[r][c]
            if val == '.':
                continue

            if (r, val) in rows:
                return False
            rows.add((r, val))

            if (c, val) in cols:
                return False
            cols.add((c, val))

            box_key = (r // 3, c // 3, val)
            if box_key in boxes:
                return False
            boxes.add(box_key)

    return True


board = [
    ["5","3",".",".","7",".",".",".","."],
    ["6",".",".","1","9","5",".",".","."],
    [".","9","8",".",".",".",".","6","."],
    ["8",".",".",".","6",".",".",".","3"],
    ["4",".",".","8",".","3",".",".","1"],
    ["7",".",".",".","2",".",".",".","6"],
    [".","6",".",".",".",".","2","8","."],
    [".",".",".","4","1","9",".",".","5"],
    [".",".",".",".","8",".",".","7","9"],
]
print(isValidSudoku(board))  # True

board[0][1] = "5"  # duplicate in row 0
print(isValidSudoku(board))  # False

Complexity

• Time: O(1) — 81 cells, fixed
• Space: O(1) — at most 81 * 3 = 243 entries across all sets, which is constant

Common Pitfalls

Forgetting to skip '.' cells. Empty cells should not be validated — they represent unfilled positions. Always check if val == '.' before processing.

Box index calculation. The box for cell (r, c) is identified by (r // 3, c // 3). Box (0,0) covers rows 0–2 and columns 0–2; box (1,2) covers rows 3–5 and columns 6–8.

Thinking the board must be solvable. Validity only requires that the existing digits do not violate the three rules. A board with all cells empty is valid. A board with the digit 5 in every cell of the first row is invalid — regardless of whether the rest of the board could be filled in.

Longest Consecutive Sequence

Difficulty: Medium Source: NeetCode

Problem

Given an unsorted array of integers nums, return the length of the longest consecutive elements sequence.

You must write an algorithm that runs in O(n) time.

Example 1: Input: nums = [100, 4, 200, 1, 3, 2] Output: 4 (The longest consecutive sequence is [1, 2, 3, 4])

Example 2: Input: nums = [0, 3, 7, 2, 5, 8, 4, 6, 0, 1] Output: 9

Constraints:

• 0 <= nums.length <= 10^5
• -10^9 <= nums[i] <= 10^9

Prerequisites

Before attempting this problem, you should be comfortable with:

• Hash Sets — O(1) average-case lookup
• Sequence start detection — identifying where a consecutive run begins

1. Brute Force (Sort and Scan)

Intuition

Sort the array first. Then scan through it: if the current number is exactly 1 more than the previous, extend the current streak; if it is the same as the previous (duplicate), skip it; otherwise, start a new streak. Track the maximum streak seen.

Algorithm

1. Handle edge case: if nums is empty, return 0.
2. Sort nums.
3. Track current_streak = 1 and best = 1.
4. For each index i from 1 to n - 1:
   • If nums[i] == nums[i - 1]: skip (duplicate).
   • If nums[i] == nums[i - 1] + 1: increment current_streak, update best.
   • Else: reset current_streak = 1.
5. Return best.

Solution

def longestConsecutive(nums):
    if not nums:
        return 0
    nums.sort()
    best = 1
    current = 1
    for i in range(1, len(nums)):
        if nums[i] == nums[i - 1]:
            continue           # skip duplicates
        elif nums[i] == nums[i - 1] + 1:
            current += 1
            best = max(best, current)
        else:
            current = 1
    return best


print(longestConsecutive([100, 4, 200, 1, 3, 2]))           # 4
print(longestConsecutive([0, 3, 7, 2, 5, 8, 4, 6, 0, 1]))  # 9
print(longestConsecutive([]))                                # 0

Complexity

• Time: O(n log n) — dominated by the sort
• Space: O(1) extra

2. Hash Set (O(n))

Intuition

The key insight: a consecutive sequence [a, a+1, a+2, ..., a+k] has exactly one starting point — the number a where a - 1 is NOT in the array. If we only start counting from sequence beginnings, each number is counted at most once across all sequences.

Build a hash set of all numbers for O(1) lookup. For each number n, check if n - 1 is in the set. If not, n is the start of a sequence — count upwards from there. Skip numbers where n - 1 exists because they belong to a sequence already counted.

Algorithm

1. Build num_set = set(nums).
2. Initialize best = 0.
3. For each num in num_set:
   • If num - 1 is NOT in num_set (i.e., num is a sequence start):
     • Count streak: while num + streak is in num_set, increment streak.
     • Update best = max(best, streak).
4. Return best.

flowchart LR
    S(["num_set = {100,4,200,1,3,2}"])
    S --> a["num=100: 99 not in set → count: 100,101? no → streak=1"]
    a --> b["num=4: 3 in set → skip (not a start)"]
    b --> c["num=200: 199 not in set → count: 200,201? no → streak=1"]
    c --> d["num=1: 0 not in set → count: 1,2,3,4 → streak=4"]
    d --> e["num=3: 2 in set → skip"]
    e --> f["num=2: 1 in set → skip"]
    f --> R(["best=4"])

Solution

def longestConsecutive(nums):
    num_set = set(nums)
    best = 0

    for num in num_set:
        # Only start counting from the beginning of a sequence
        if num - 1 not in num_set:
            streak = 1
            while num + streak in num_set:
                streak += 1
            best = max(best, streak)

    return best


print(longestConsecutive([100, 4, 200, 1, 3, 2]))           # 4
print(longestConsecutive([0, 3, 7, 2, 5, 8, 4, 6, 0, 1]))  # 9
print(longestConsecutive([]))                                # 0

Complexity

• Time: O(n) — building the set is O(n). Each number is visited at most twice: once in the outer loop (to check if it is a start), and at most once in the inner while loop (only when it is part of a sequence being counted). Total inner loop iterations across all starting points is bounded by n.
• Space: O(n) — the hash set

Common Pitfalls

Iterating over the original list vs. the set. Iterating over nums (with duplicates) instead of num_set is safe but wastes time on duplicates. Iterating over num_set ensures we consider each unique value once.

Restarting counts for non-starts. Without the if num - 1 not in num_set guard, you would count sequences starting at every element — including elements in the middle of a sequence. This makes the inner while loop run redundantly and inflates runtime to O(n²) in the worst case.

Empty input. If nums is empty, the for loop does not execute and best stays at 0 — correct, no special case needed.

Best Time to Buy and Sell Stock II

Difficulty: Medium Source: NeetCode

Problem

You are given an integer array prices where prices[i] is the price of a given stock on the i-th day.

On each day, you may decide to buy and/or sell the stock. You can only hold at most one share of the stock at any time. However, you can buy it then immediately sell it on the same day.

Return the maximum profit you can achieve.

Example 1: Input: prices = [7, 1, 5, 3, 6, 4] Output: 7 Explanation: Buy on day 2 (price=1), sell on day 3 (price=5), profit=4. Buy on day 4 (price=3), sell on day 5 (price=6), profit=3. Total=7.

Example 2: Input: prices = [1, 2, 3, 4, 5] Output: 4 Explanation: Buy on day 1, sell on day 5. Profit=4.

Example 3: Input: prices = [7, 6, 4, 3, 1] Output: 0 Explanation: No profitable transaction possible.

Constraints:

• 1 <= prices.length <= 3 * 10^4
• 0 <= prices[i] <= 10^4

Prerequisites

Before attempting this problem, you should be comfortable with:

• Greedy algorithms — making locally optimal choices that lead to a global optimum
• Peaks and valleys — identifying upward and downward trends in a sequence

1. Peaks and Valleys

Intuition

To maximise profit, we want to buy at every valley (local minimum) and sell at every peak (local maximum). Between any valley and peak, we capture the full upward movement of the stock price.

Scan through the prices and whenever the current price is lower than the next price, buy (or keep holding). When the current price is higher than the next, sell. Accumulate all upward movements.

Algorithm

1. Initialize profit = 0, i = 0.
2. While i < n - 1:
   • Find valley: while prices[i] >= prices[i + 1], increment i.
   • Find peak: while prices[i] <= prices[i + 1], increment i.
   • Add prices[peak] - prices[valley] to profit.
3. Return profit.

Solution

def maxProfit(prices):
    profit = 0
    i = 0
    n = len(prices)
    while i < n - 1:
        # Find valley
        while i < n - 1 and prices[i] >= prices[i + 1]:
            i += 1
        valley = prices[i]
        # Find peak
        while i < n - 1 and prices[i] <= prices[i + 1]:
            i += 1
        peak = prices[i]
        profit += peak - valley
    return profit


print(maxProfit([7, 1, 5, 3, 6, 4]))   # 7
print(maxProfit([1, 2, 3, 4, 5]))       # 4
print(maxProfit([7, 6, 4, 3, 1]))       # 0

Complexity

• Time: O(n)
• Space: O(1)

2. Greedy (Sum Positive Differences)

Intuition

Here is the key insight that simplifies everything: since we can buy and sell on consecutive days, we can decompose any profit into the sum of single-day gains.

For example, buying at price 1 on day 1 and selling at price 5 on day 4 gives profit 4. But this is the same as buying and selling each day: (2-1) + (3-2) + (4-3) + (5-4) = 1 + 1 + 1 + 1 = 4. The intermediate buy-sell steps cancel out.

So: just sum up all positive consecutive differences. If prices[i+1] > prices[i], add the difference to profit. Ignore negative differences (do not trade on down days).

Algorithm

1. Initialize profit = 0.
2. For each index i from 0 to n - 2:
   • If prices[i + 1] > prices[i]: add prices[i + 1] - prices[i] to profit.
3. Return profit.

flowchart LR
    A(["prices = [7,1,5,3,6,4]"])
    A --> a["day 0→1: 1-7=-6  →  skip"]
    a --> b["day 1→2: 5-1=+4  →  profit+=4"]
    b --> c["day 2→3: 3-5=-2  →  skip"]
    c --> d["day 3→4: 6-3=+3  →  profit+=3"]
    d --> e["day 4→5: 4-6=-2  →  skip"]
    e --> R(["profit=7"])

Solution

def maxProfit(prices):
    profit = 0
    for i in range(len(prices) - 1):
        if prices[i + 1] > prices[i]:
            profit += prices[i + 1] - prices[i]
    return profit


print(maxProfit([7, 1, 5, 3, 6, 4]))   # 7
print(maxProfit([1, 2, 3, 4, 5]))       # 4
print(maxProfit([7, 6, 4, 3, 1]))       # 0

Complexity

• Time: O(n) — one pass
• Space: O(1)

Common Pitfalls

Confusing this with Best Time to Buy and Sell Stock I. In problem I, you can only make one transaction. Here, unlimited transactions are allowed. The greedy approach only works because you can trade as many times as you want.

Trying to track buy/sell days. You do not need to know exactly which days to buy and sell to compute the maximum profit. The sum-of-positive-differences trick gives the correct answer without tracking individual transactions.

Selling before buying. You must buy before you can sell. The consecutive-day trick handles this automatically — we only add gains from one day to the next, never going backwards in time.

Majority Element II

Difficulty: Medium Source: NeetCode

Problem

Given an integer array of size n, find all elements that appear more than ⌊n / 3⌋ times.

Example 1: Input: nums = [3, 2, 3] Output: [3]

Example 2: Input: nums = [1, 2] Output: [1, 2]

Example 3: Input: nums = [3, 2, 3, 2, 1, 2] Output: [3, 2]

Constraints:

• 1 <= nums.length <= 5 * 10^4
• -10^9 <= nums[i] <= 10^9

Prerequisites

Before attempting this problem, you should be comfortable with:

• Hash Maps — frequency counting
• Boyer-Moore Voting Algorithm — from Majority Element I
• Mathematical observation — at most 2 elements can appear more than n/3 times

1. Hash Map Count

Intuition

Count every element’s frequency with a hash map, then collect all elements whose count exceeds n // 3. This is direct and easy to verify.

Algorithm

1. Build a frequency map count.
2. Threshold = n // 3.
3. Return all elements with count[num] > threshold.

Solution

def majorityElement(nums):
    n = len(nums)
    count = {}
    for num in nums:
        count[num] = count.get(num, 0) + 1
    threshold = n // 3
    return [num for num, freq in count.items() if freq > threshold]


print(majorityElement([3, 2, 3]))           # [3]
print(majorityElement([1, 2]))              # [1, 2]
print(majorityElement([3, 2, 3, 2, 1, 2])) # [3, 2]

Complexity

• Time: O(n)
• Space: O(n) — the hash map

2. Boyer-Moore Voting with Two Candidates

Intuition

Key observation: At most 2 elements can appear more than n/3 times. Why? If three elements each appeared more than n/3 times, they would collectively account for more than n elements — impossible.

Extending Boyer-Moore to find at most 2 candidates:

Maintain two candidates (c1, c2) and their respective counts (cnt1, cnt2). For each number:

• If it matches c1, increment cnt1.
• Else if it matches c2, increment cnt2.
• Else if cnt1 == 0, replace c1 with the current number.
• Else if cnt2 == 0, replace c2 with the current number.
• Else both candidates differ — decrement both counts (cancel one of each).

After the first pass, c1 and c2 are candidates. Do a second pass to verify both actually exceed n // 3 (since the voting pass finds candidates, not guaranteed winners).

Algorithm

1. Phase 1: Find two candidates using the extended voting algorithm.
2. Phase 2: Count actual occurrences of c1 and c2; include those exceeding n // 3.

flowchart LR
    S(["nums=[3,2,3,2,1,2]  c1=None cnt1=0  c2=None cnt2=0"])
    S --> a["3: cnt1=0 → c1=3 cnt1=1"]
    a --> b["2: cnt2=0 → c2=2 cnt2=1"]
    b --> c["3: matches c1 → cnt1=2"]
    c --> d["2: matches c2 → cnt2=2"]
    d --> e["1: neither, cnt1>0 cnt2>0 → cnt1=1 cnt2=1"]
    e --> f["2: matches c2 → cnt2=2"]
    f --> G["Phase 2: count(3)=2 > 6//3=2? No! count(2)=3>2? Yes"]
    G --> R(["result=[2]  ... wait: count(3)=2 not > 2"])

Note: > not >= — so for [3,2,3,2,1,2] (n=6), threshold is 2, count(3)=2 is NOT > 2, count(2)=3 IS > 2. Let’s verify: [1,2] (n=2), threshold=0, both count 1 which is > 0. Correct.

Solution

def majorityElement(nums):
    # Phase 1: find candidates
    c1, c2 = None, None
    cnt1, cnt2 = 0, 0

    for num in nums:
        if num == c1:
            cnt1 += 1
        elif num == c2:
            cnt2 += 1
        elif cnt1 == 0:
            c1, cnt1 = num, 1
        elif cnt2 == 0:
            c2, cnt2 = num, 1
        else:
            cnt1 -= 1
            cnt2 -= 1

    # Phase 2: verify candidates
    n = len(nums)
    threshold = n // 3
    result = []
    for candidate in [c1, c2]:
        if candidate is not None and nums.count(candidate) > threshold:
            result.append(candidate)

    return result


print(majorityElement([3, 2, 3]))           # [3]
print(majorityElement([1, 2]))              # [1, 2]
print(majorityElement([3, 2, 3, 2, 1, 2])) # [2]
print(majorityElement([2, 2]))              # [2]

Complexity

• Time: O(n) — two passes (the nums.count() calls are each O(n), but constants)
• Space: O(1) — four variables only

Common Pitfalls

Skipping the verification pass. The voting algorithm finds candidates but does not guarantee they exceed the threshold. A second pass to verify their actual counts is mandatory. For example, in [1, 2, 3], every element is a candidate but none appears more than once (threshold = 3 // 3 = 1), so the answer is [].

Using >= instead of > for the threshold. The problem asks for elements appearing more than n/3 times, not at least n/3 times.

Not handling duplicate candidates. If the same value becomes both c1 and c2 due to implementation bugs, the verification phase handles it — each candidate is checked independently.

Subarray Sum Equals K

Difficulty: Medium Source: NeetCode

Problem

Given an array of integers nums and an integer k, return the total number of subarrays whose sum equals k.

A subarray is a contiguous non-empty sequence of elements within an array.

Example 1: Input: nums = [1, 1, 1], k = 2 Output: 2

Example 2: Input: nums = [1, 2, 3], k = 3 Output: 2

Constraints:

• 1 <= nums.length <= 2 * 10^4
• -1000 <= nums[i] <= 1000
• -10^7 <= k <= 10^7

Prerequisites

Before attempting this problem, you should be comfortable with:

• Prefix sums — cumulative sums from the start of the array
• Hash Maps — counting how many times a value has been seen
• Complement trick — if prefix[j] - prefix[i] == k, then subarray i+1..j sums to k

1. Brute Force (All Subarrays)

Intuition

Try every possible subarray. For each starting index i, extend the subarray rightward and keep a running sum. When the running sum equals k, increment the count.

Algorithm

1. Initialize count = 0.
2. For each i from 0 to n - 1:
   • Set total = 0.
   • For each j from i to n - 1:
     • Add nums[j] to total.
     • If total == k, increment count.
3. Return count.

Solution

def subarraySum(nums, k):
    count = 0
    n = len(nums)
    for i in range(n):
        total = 0
        for j in range(i, n):
            total += nums[j]
            if total == k:
                count += 1
    return count


print(subarraySum([1, 1, 1], 2))   # 2
print(subarraySum([1, 2, 3], 3))   # 2
print(subarraySum([1], 0))         # 0

Complexity

• Time: O(n²)
• Space: O(1)

2. Prefix Sum with Hash Map

Intuition

Let prefix[i] = sum of nums[0..i]. A subarray from index i+1 to j sums to k when:

prefix[j] - prefix[i] == k
  →  prefix[i] == prefix[j] - k

So for each position j, the number of valid subarrays ending at j equals the number of times prefix[j] - k has appeared as a prefix sum before position j.

We track prefix sum occurrences in a hash map as we scan. The map starts with {0: 1} to handle the case where the prefix sum itself equals k (the entire prefix from index 0 to j is a valid subarray).

Algorithm

1. Initialize prefix_counts = {0: 1}, prefix = 0, count = 0.
2. For each num in nums:
   • Update prefix += num.
   • Add prefix_counts.get(prefix - k, 0) to count.
   • Increment prefix_counts[prefix] by 1.
3. Return count.

flowchart LR
    S(["nums=[1,1,1]  k=2  prefix_counts={0:1}  prefix=0"])
    S --> a["num=1: prefix=1  check(1-2=-1)→0  count=0  map={0:1,1:1}"]
    a --> b["num=1: prefix=2  check(2-2=0)→1  count=1  map={0:1,1:1,2:1}"]
    b --> c["num=1: prefix=3  check(3-2=1)→1  count=2  map={0:1,1:1,2:1,3:1}"]
    c --> R(["return 2"])

Solution

def subarraySum(nums, k):
    prefix_counts = {0: 1}  # prefix sum 0 has been seen once (before any element)
    prefix = 0
    count = 0

    for num in nums:
        prefix += num
        # How many earlier prefixes satisfy: prefix - earlier_prefix == k
        count += prefix_counts.get(prefix - k, 0)
        # Record this prefix sum
        prefix_counts[prefix] = prefix_counts.get(prefix, 0) + 1

    return count


print(subarraySum([1, 1, 1], 2))    # 2
print(subarraySum([1, 2, 3], 3))    # 2
print(subarraySum([1], 0))          # 0

Complexity

• Time: O(n) — one pass with O(1) hash map operations
• Space: O(n) — hash map holds at most n + 1 distinct prefix sums

Common Pitfalls

Not initialising prefix_counts = {0: 1}. Without this, you miss subarrays that start from index 0 (i.e., where the prefix sum from the very beginning equals k). For example, nums = [3], k = 3 should return 1, but without the initial {0: 1} it returns 0.

Checking before updating the map. You must look up prefix - k in the map BEFORE adding the current prefix to the map. Adding first would allow a subarray to “match itself” — counting a zero-length subarray.

Negative numbers and zeros. Unlike the sliding window technique (which only works for positive numbers), prefix sum with a hash map handles negative numbers and zeros correctly. No special casing required.

First Missing Positive

Difficulty: Hard Source: NeetCode

Problem

Given an unsorted integer array nums, return the smallest missing positive integer.

You must implement an algorithm that runs in O(n) time and uses O(1) auxiliary space.

Example 1: Input: nums = [1, 2, 0] Output: 3

Example 2: Input: nums = [3, 4, -1, 1] Output: 2

Example 3: Input: nums = [7, 8, 9, 11, 12] Output: 1

Constraints:

• 1 <= nums.length <= 5 * 10^5
• -2^31 <= nums[i] <= 2^31 - 1

Prerequisites

Before attempting this problem, you should be comfortable with:

• Arrays as hash sets — using indices to record the presence of values
• Index marking — using sign changes to encode boolean information within an array
• Pigeonhole principle — the answer must be in the range [1, n+1]

1. Hash Set

Intuition

Put all elements into a hash set, then scan positive integers starting from 1 until you find one that is missing. This is O(n) time and O(n) space — clean and correct, but uses extra memory.

Algorithm

1. Convert nums to a set seen.
2. For i = 1, 2, 3, ...:
   • If i is not in seen, return i.

Solution

def firstMissingPositive(nums):
    seen = set(nums)
    i = 1
    while i in seen:
        i += 1
    return i


print(firstMissingPositive([1, 2, 0]))        # 3
print(firstMissingPositive([3, 4, -1, 1]))    # 2
print(firstMissingPositive([7, 8, 9, 11, 12]))  # 1

Complexity

• Time: O(n)
• Space: O(n) — the hash set

2. Index Marking (O(1) Space)

Intuition

Key observation (pigeonhole): Given an array of n elements, the first missing positive must be in the range [1, n+1]. Why? If all of 1, 2, ..., n are present, the answer is n+1. If any of them is missing, the answer is at most n.

This means we only care about values in [1, n] — everything else is irrelevant.

The trick: Use the array itself as a hash set. To mark that value v is present, negate the element at index v - 1. After marking, the first index i with a positive value means i + 1 is missing.

Three-phase algorithm:

1. Clean up: Replace any value that is not in [1, n] with a sentinel (e.g., n+1) so it does not interfere with marking.
2. Mark: For each value v = abs(nums[i]) in [1, n], negate nums[v - 1] if it is positive (to avoid double-negation).
3. Scan: The first index i with nums[i] > 0 means i + 1 is missing. If all are negative, return n + 1.

Algorithm

1. Replace all values <= 0 or > n with n + 1.
2. For each i in range n:
   • Let v = abs(nums[i]).
   • If 1 <= v <= n and nums[v - 1] > 0: negate nums[v - 1].
3. For each i in range n:
   • If nums[i] > 0: return i + 1.
4. Return n + 1.

flowchart LR
    A(["nums=[3,4,-1,1]  n=4"])
    A --> B["Phase 1: replace -1→5  →  [3,4,5,1]"]
    B --> C["Phase 2: mark\n  v=3→nums[2]=-5\n  v=4→nums[3]=-1\n  v=5→out of range skip\n  v=1→nums[0]=-3\n  result: [-3,4,-5,-1]"]
    C --> D["Phase 3: scan\n  i=0 negative skip\n  i=1 positive! → return 2"]
    D --> R(["return 2"])

Solution

def firstMissingPositive(nums):
    n = len(nums)

    # Phase 1: replace out-of-range values with n+1 (a safe sentinel)
    for i in range(n):
        if nums[i] <= 0 or nums[i] > n:
            nums[i] = n + 1

    # Phase 2: mark presence of values 1..n by negating the element at that index
    for i in range(n):
        v = abs(nums[i])
        if 1 <= v <= n and nums[v - 1] > 0:
            nums[v - 1] = -nums[v - 1]

    # Phase 3: first index with a positive value → that index+1 is missing
    for i in range(n):
        if nums[i] > 0:
            return i + 1

    return n + 1


print(firstMissingPositive([1, 2, 0]))           # 3
print(firstMissingPositive([3, 4, -1, 1]))       # 2
print(firstMissingPositive([7, 8, 9, 11, 12]))   # 1

Complexity

• Time: O(n) — three independent linear passes
• Space: O(1) — we reuse the input array for marking (no extra data structures)

Why the Marking Works

After phase 1, every value is either in [1, n] or the sentinel n+1. In phase 2, we use index v - 1 as a “presence flag” for value v. Negating nums[v-1] records “value v exists” without losing the original value v (we recover it via abs()).

After phase 2:

• nums[i] < 0 means value i + 1 WAS present in the original array.
• nums[i] > 0 means value i + 1 was NOT present — it is a candidate for the first missing positive.

Common Pitfalls

Double-negation. When marking nums[v-1], check that it is still positive before negating. If it is already negative (marked by a previous duplicate), negating it again would undo the mark. Always check if nums[v - 1] > 0 before negating.

Using abs() in the marking phase. After some elements have been negated, nums[i] may be negative. When reading it as an index target in phase 2, always use abs(nums[i]) to recover the original value.

Off-by-one. Value v maps to index v - 1. Value 1 is at index 0, value n is at index n - 1. Be careful: if v = n + 1, there is no valid index for it — skip it (it was already cleaned up as out-of-range).

Mutating the input. This algorithm modifies nums in place. If the caller needs the original array preserved, make a copy before calling.

Best Time to Buy and Sell Stock

Difficulty: Easy Source: NeetCode

Problem

You are given an array prices where prices[i] is the price of a given stock on the ith day. You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock. Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.

Example 1: Input: prices = [7,1,5,3,6,4] Output: 5

Example 2: Input: prices = [7,6,4,3,1] Output: 0

Constraints:

• 1 <= prices.length <= 10^5
• 0 <= prices[i] <= 10^4

Prerequisites

Before attempting this problem, you should be comfortable with:

• Sliding Window (Two Pointers) — maintaining a left and right pointer to track a range of interest
• Greedy thinking — making locally optimal choices (always buy at the lowest price seen so far)

1. Brute Force

Intuition

Try every possible pair of buy and sell days. For each buy day i, check every sell day j > i and track the maximum profit. This is conceptually simple but very slow for large inputs.

Algorithm

1. For each index i (buy day), iterate over every j > i (sell day).
2. Compute profit as prices[j] - prices[i].
3. Track and return the maximum profit seen. If it never exceeds 0, return 0.

Solution

def maxProfit_brute(prices):
    max_profit = 0
    n = len(prices)
    for i in range(n):
        for j in range(i + 1, n):
            profit = prices[j] - prices[i]
            max_profit = max(max_profit, profit)
    return max_profit


# Test cases
print(maxProfit_brute([7, 1, 5, 3, 6, 4]))  # 5
print(maxProfit_brute([7, 6, 4, 3, 1]))      # 0
print(maxProfit_brute([2, 4, 1]))            # 2

Complexity

• Time: O(n²) — nested loops over all pairs
• Space: O(1) — only tracking a single max value

2. Sliding Window (One Pass)

Intuition

Think of left as the buy pointer and right as the sell pointer. Move right forward one step at a time. Whenever the price at right drops below the price at left, there’s no point holding onto that buy day — just move left to right because we found a cheaper buy price. At each step, calculate the profit and update the maximum. This is sliding window in disguise: we’re maintaining a window [left, right] where prices[left] is the minimum seen so far.

Algorithm

1. Initialize left = 0, right = 1, max_profit = 0.
2. While right < len(prices):
   • If prices[right] < prices[left], move left = right (found cheaper buy).
   • Otherwise, compute profit = prices[right] - prices[left] and update max_profit.
   • Advance right.
3. Return max_profit.

graph LR
    A["prices = [7,1,5,3,6,4]"] --> B["L=7,R=1: 1<7, move L→1"]
    B --> C["L=1,R=5: profit=4"]
    C --> D["L=1,R=3: profit=2"]
    D --> E["L=1,R=6: profit=5 ✓ max"]
    E --> F["L=1,R=4: profit=3"]
    F --> G["return 5"]

Solution

def maxProfit(prices):
    left = 0           # buy pointer
    right = 1          # sell pointer
    max_profit = 0

    while right < len(prices):
        if prices[right] < prices[left]:
            # Found a cheaper day to buy — reset the buy pointer
            left = right
        else:
            profit = prices[right] - prices[left]
            max_profit = max(max_profit, profit)
        right += 1

    return max_profit


# Test cases
print(maxProfit([7, 1, 5, 3, 6, 4]))  # 5
print(maxProfit([7, 6, 4, 3, 1]))      # 0
print(maxProfit([2, 4, 1]))            # 2

Complexity

• Time: O(n) — single pass through the array
• Space: O(1) — only a handful of variables

Common Pitfalls

Returning negative profit. If prices only decrease, every prices[right] - prices[left] is negative. Initialize max_profit = 0 (not -infinity) so you naturally return 0 when no profitable trade exists.

Selling before buying. The constraint is that you must buy before you sell — left always trails right, so the two-pointer approach naturally enforces this. Never swap or set left > right.

Single element array. With only one price, there’s no sell day, so profit is 0. The while loop condition right < len(prices) handles this without any special casing.

Maximum Subarray

Difficulty: Medium Source: NeetCode

Problem

Given an integer array nums, find the subarray with the largest sum and return its sum.

Example 1: Input: nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4] Output: 6 Explanation: The subarray [4, -1, 2, 1] has sum 6.

Example 2: Input: nums = [1] Output: 1

Example 3: Input: nums = [5, 4, -1, 7, 8] Output: 23

Constraints:

• 1 <= nums.length <= 10^5
• -10^4 <= nums[i] <= 10^4

Prerequisites

Before attempting this problem, you should be comfortable with:

• Greedy thinking — knowing when to abandon a running sum
• Dynamic programming basics — dp[i] in terms of dp[i-1]

1. Brute Force

Intuition

Try every possible subarray. For each starting index i, compute the sum of all subarrays starting at i and track the maximum. This is O(n²) — correct but slow.

Algorithm

1. Initialise max_sum = -infinity.
2. For each i from 0 to n-1:
   • running = 0
   • For each j from i to n-1:
     • running += nums[j]
     • max_sum = max(max_sum, running)
3. Return max_sum.

Solution

def maxSubArray(nums):
    max_sum = float('-inf')
    for i in range(len(nums)):
        running = 0
        for j in range(i, len(nums)):
            running += nums[j]
            max_sum = max(max_sum, running)
    return max_sum


print(maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4]))  # 6
print(maxSubArray([1]))                                 # 1
print(maxSubArray([5, 4, -1, 7, 8]))                   # 23
print(maxSubArray([-1, -2, -3]))                        # -1

Complexity

• Time: O(n²)
• Space: O(1)

2. Kadane’s Algorithm (Greedy / DP)

Intuition

At each index, decide: should we extend the current subarray or start a new one here? If the current running sum is negative, it can only drag down any future subarray — so we drop it and restart from the current element. Otherwise, we extend. This greedy decision is optimal: a negative prefix never helps.

More formally, dp[i] = max(nums[i], dp[i-1] + nums[i]). We only need the previous value, so we use a single variable.

Algorithm

1. Initialise current = nums[0], max_sum = nums[0].
2. For each num in nums[1:]:
   • current = max(num, current + num) — start fresh or extend.
   • max_sum = max(max_sum, current).
3. Return max_sum.

Solution

def maxSubArray(nums):
    current = nums[0]
    max_sum = nums[0]

    for num in nums[1:]:
        current = max(num, current + num)
        max_sum = max(max_sum, current)

    return max_sum


print(maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4]))  # 6
print(maxSubArray([1]))                                 # 1
print(maxSubArray([5, 4, -1, 7, 8]))                   # 23
print(maxSubArray([-1, -2, -3]))                        # -1
print(maxSubArray([-2, -1]))                            # -1


# Equivalent formulation: drop the prefix when it goes negative
def maxSubArray_v2(nums):
    max_sum = nums[0]
    current = 0

    for num in nums:
        current += num
        max_sum = max(max_sum, current)
        if current < 0:
            current = 0  # reset: negative prefix helps nobody

    return max_sum


print(maxSubArray_v2([-2, 1, -3, 4, -1, 2, 1, -5, 4]))  # 6

Complexity

• Time: O(n)
• Space: O(1)

Common Pitfalls

Initialising max_sum = 0. If all elements are negative, the best subarray is the single largest element. Starting at 0 would incorrectly return 0 for an all-negative array. Always initialise with nums[0] or -infinity.

Resetting current to 0 but forgetting to update max_sum first. In the “reset on negative” variant, update max_sum = max(max_sum, current) before resetting current. Otherwise you’ll miss the max that occurred just before the reset.

Confusing this with Maximum Subarray Sum with No Adjacent Elements. That’s a different problem (house robber variant). This problem allows any contiguous subarray, including one of length 1.

Maximum Sum Circular Subarray

Difficulty: Medium Source: NeetCode

Problem

Given a circular integer array nums (last element wraps to first), return the maximum possible sum of a non-empty subarray of nums.

Example 1: Input: nums = [1, -2, 3, -2] Output: 3

Example 2: Input: nums = [5, -3, 5] Output: 10

Example 3: Input: nums = [-3, -2, -3] Output: -2

Constraints:

• 1 <= nums.length <= 3 * 10^4
• -3 * 10^4 <= nums[i] <= 3 * 10^4

Prerequisites

Before attempting this problem, you should be comfortable with:

• Maximum Subarray (Kadane’s) — the non-circular version is a building block
• Complement thinking — the circular max relates to the total sum and the minimum subarray

1. Brute Force

Intuition

For each starting position i, compute the sum of every subarray that wraps around or doesn’t. To simulate circularity, we can double the array and run Kadane’s on it. But even simpler: for each starting index, sum in a sliding window of length up to n. This is O(n²).

Algorithm

1. Double the array: doubled = nums + nums.
2. For each start i from 0 to n-1:
   • Sum all subarrays doubled[i:i+k] for k from 1 to n.
   • Track the maximum.
3. Return the maximum.

Solution

def maxSubarraySumCircular(nums):
    n = len(nums)
    doubled = nums + nums
    max_sum = float('-inf')

    for i in range(n):
        running = 0
        for j in range(i, i + n):
            running += doubled[j]
            max_sum = max(max_sum, running)

    return max_sum


print(maxSubarraySumCircular([1, -2, 3, -2]))    # 3
print(maxSubarraySumCircular([5, -3, 5]))         # 10
print(maxSubarraySumCircular([-3, -2, -3]))       # -2

Complexity

• Time: O(n²)
• Space: O(n) — doubled array

2. Greedy — Total Sum Minus Minimum Subarray

Intuition

A subarray in a circular array either:

1. Does not wrap around — this is just the regular max subarray (Kadane’s).
2. Wraps around — the subarray covers the start and end of the array.

For case 2, the elements not in the subarray form a contiguous middle section. So the circular max = total_sum - min_subarray_sum. We want to maximise the kept portion, which means minimising what we throw away.

Run Kadane’s twice:

• Once for max subarray (case 1).
• Once for min subarray (case 2).

Answer = max(max_sub, total - min_sub).

Edge case: if all elements are negative, min_sub == total, meaning we’d be returning 0 for case 2. But the answer must be non-empty, so we take max_sub in that case (the least negative single element).

Algorithm

1. Compute total = sum(nums).
2. Run Kadane’s for max_sub.
3. Run Kadane’s (minimising) for min_sub.
4. If max_sub < 0, return max_sub (all negatives edge case).
5. Return max(max_sub, total - min_sub).

Solution

def maxSubarraySumCircular(nums):
    def kadane_max(arr):
        cur = best = arr[0]
        for num in arr[1:]:
            cur = max(num, cur + num)
            best = max(best, cur)
        return best

    def kadane_min(arr):
        cur = best = arr[0]
        for num in arr[1:]:
            cur = min(num, cur + num)
            best = min(best, cur)
        return best

    total = sum(nums)
    max_sub = kadane_max(nums)
    min_sub = kadane_min(nums)

    # Edge case: all negative, circular answer would be 0 (empty), but must be non-empty
    if max_sub < 0:
        return max_sub

    return max(max_sub, total - min_sub)


print(maxSubarraySumCircular([1, -2, 3, -2]))    # 3
print(maxSubarraySumCircular([5, -3, 5]))         # 10
print(maxSubarraySumCircular([-3, -2, -3]))       # -2
print(maxSubarraySumCircular([3, -1, 2, -1]))     # 4
print(maxSubarraySumCircular([3, -2, 2, -3]))     # 3

Complexity

• Time: O(n)
• Space: O(1)

Common Pitfalls

Returning total - min_sub when all elements are negative. If all elements are negative, min_sub == total, so total - min_sub = 0. But a subarray must be non-empty — the correct answer is the maximum single element (which Kadane’s max gives us). Always check if max_sub < 0.

Using Kadane’s on a doubled array without capping length. If you run Kadane’s on nums + nums without restricting to n elements, you might pick a subarray longer than n — which isn’t a valid circular subarray.

Forgetting that case 2 can’t be the entire array. total - min_sub requires that min_sub be a proper non-empty subarray. If min_sub is the entire array, the “kept” portion is empty — which is invalid. The all-negative edge case catches this.

Longest Turbulent Subarray

Difficulty: Medium Source: NeetCode

Problem

A subarray is turbulent if the comparison sign alternates between each adjacent pair of elements. That is, for arr[i], arr[i+1], arr[i+2], we need either arr[i] > arr[i+1] < arr[i+2] or arr[i] < arr[i+1] > arr[i+2]. Return the length of the longest turbulent subarray.

Example 1: Input: nums = [9, 4, 2, 10, 7, 8, 8, 1, 9] Output: 5 Explanation: [4, 2, 10, 7, 8] is turbulent.

Example 2: Input: nums = [4, 8, 12, 16] Output: 2

Example 3: Input: nums = [100] Output: 1

Constraints:

• 1 <= nums.length <= 4 * 10^4
• 0 <= nums[i] <= 10^9

Prerequisites

Before attempting this problem, you should be comfortable with:

• Sliding Window — expanding and contracting a window based on conditions
• Maximum Subarray / Kadane’s — similar “extend or restart” pattern

1. Brute Force

Intuition

For each starting index, extend the subarray as long as it remains turbulent. Check each new element — if the alternating comparison property breaks, stop and record the length. Try all starting positions and track the maximum.

Algorithm

1. For each start i:
   • Extend j = i + 1, i + 2, ... while the subarray is turbulent.
   • Turbulence breaks when adjacent comparisons don’t alternate.
   • Record j - i as the length.
2. Return the maximum.

Solution

def maxTurbulenceSize(nums):
    n = len(nums)
    if n == 1:
        return 1

    def is_turbulent(arr):
        for i in range(1, len(arr) - 1):
            if arr[i - 1] < arr[i] and arr[i] < arr[i + 1]:
                return False
            if arr[i - 1] > arr[i] and arr[i] > arr[i + 1]:
                return False
            if arr[i - 1] == arr[i] or arr[i] == arr[i + 1]:
                return False
        return True

    max_len = 1
    for i in range(n):
        for j in range(i + 2, n + 1):
            if is_turbulent(nums[i:j]):
                max_len = max(max_len, j - i)
    return max_len


print(maxTurbulenceSize([9, 4, 2, 10, 7, 8, 8, 1, 9]))  # 5
print(maxTurbulenceSize([4, 8, 12, 16]))                  # 2
print(maxTurbulenceSize([100]))                            # 1

Complexity

• Time: O(n³) — outer loops are O(n²), inner check is O(n)
• Space: O(n)

2. Greedy — Sliding Window / Linear Scan

Intuition

Scan left to right. Keep track of the previous comparison direction (prev). If the current pair forms the opposite comparison from the previous (alternating), extend the current turbulent subarray. If they’re equal or continue in the same direction, the turbulence breaks — restart from the current position. This is exactly like Kadane’s “extend or restart” pattern.

Algorithm

1. Initialise max_len = 1, cur_len = 1.
2. For i from 1 to n-1:
   • Compute cmp: -1 if nums[i] < nums[i-1], 1 if greater, 0 if equal.
   • If cmp == 0: reset cur_len = 1.
   • Elif i == 1 or cmp == prev: cur_len = 2 (pair is valid but not alternating with before).
   • Else: cur_len += 1 (successfully alternated).
   • Update max_len = max(max_len, cur_len).
   • Set prev = cmp.
3. Return max_len.

Solution

def maxTurbulenceSize(nums):
    n = len(nums)
    if n == 1:
        return 1

    max_len = 1
    cur_len = 1
    prev = 0  # -1, 0, or 1

    for i in range(1, n):
        if nums[i] > nums[i - 1]:
            cmp = 1
        elif nums[i] < nums[i - 1]:
            cmp = -1
        else:
            cmp = 0

        if cmp == 0:
            cur_len = 1
        elif cmp == -prev:
            cur_len += 1  # alternated correctly
        else:
            cur_len = 2   # valid pair but didn't extend turbulence

        prev = cmp
        max_len = max(max_len, cur_len)

    return max_len


print(maxTurbulenceSize([9, 4, 2, 10, 7, 8, 8, 1, 9]))  # 5
print(maxTurbulenceSize([4, 8, 12, 16]))                  # 2
print(maxTurbulenceSize([100]))                            # 1
print(maxTurbulenceSize([9, 9]))                           # 1
print(maxTurbulenceSize([2, 0, 4, 3, 4]))                 # 5


# Cleaner version using sign comparison
def maxTurbulenceSize_v2(nums):
    n = len(nums)
    max_len = cur_len = 1

    for i in range(1, n):
        if nums[i] == nums[i - 1]:
            cur_len = 1
        elif i == 1:
            cur_len = 2
        elif (nums[i] > nums[i - 1]) != (nums[i - 1] > nums[i - 2]):
            cur_len += 1
        else:
            cur_len = 2
        max_len = max(max_len, cur_len)

    return max_len


print(maxTurbulenceSize_v2([9, 4, 2, 10, 7, 8, 8, 1, 9]))  # 5

Complexity

• Time: O(n)
• Space: O(1)

Common Pitfalls

Not resetting to 2 (not 1) when turbulence breaks. When the current pair (nums[i-1], nums[i]) forms a valid comparison but doesn’t continue the alternation, the subarray resets but includes the current pair. The length is 2, not 1.

Treating equal elements as valid turbulence. Two equal adjacent elements immediately break turbulence. Reset cur_len = 1 (not 2) when nums[i] == nums[i-1].

Comparing only adjacent pairs. Turbulence requires alternating comparisons — you need to check each pair against the previous pair’s direction, not just whether the current pair goes up or down.

Find The Duplicate Number

Difficulty: Medium Source: NeetCode

Problem

Given an array of integers nums containing n + 1 integers where each integer is in the range [1, n] inclusive. There is only one repeated number in nums, return this repeated number. You must solve the problem without modifying the array nums and using only constant extra space.

Example 1: Input: nums = [1,3,4,2,2] Output: 2

Example 2: Input: nums = [3,1,3,4,2] Output: 3

Constraints:

• 1 <= n <= 10^5
• nums.length == n + 1
• 1 <= nums[i] <= n
• There is only one repeated number in nums

Prerequisites

Before attempting this problem, you should be comfortable with:

• Hash Sets — O(1) average-case lookup for tracking seen elements
• Floyd’s Cycle Detection — slow/fast pointers for detecting cycles (see problem 3)
• Index-as-Pointer Thinking — treating array values as “next pointers” to model a linked list

1. Brute Force — Hash Set

Intuition

Walk through the array. Keep a set of numbers we’ve seen so far. The first number we see twice is the duplicate. Simple, but uses O(n) extra space which violates the optimal constraint.

Algorithm

1. Initialize an empty set seen.
2. For each number n in nums:
   • If n is already in seen, return n.
   • Otherwise, add n to seen.

Solution

def findDuplicate_brute(nums):
    seen = set()
    for n in nums:
        if n in seen:
            return n
        seen.add(n)
    return -1  # guaranteed to find one

# Test cases
print(findDuplicate_brute([1, 3, 4, 2, 2]))  # 2
print(findDuplicate_brute([3, 1, 3, 4, 2]))  # 3
print(findDuplicate_brute([1, 1]))            # 1
print(findDuplicate_brute([2, 2, 2, 2, 2]))  # 2

Complexity

• Time: O(n) — single pass
• Space: O(n) — hash set stores up to n elements

2. Floyd’s Cycle Detection — O(1) Space (Optimal)

Intuition

This is the clever one. The key insight: model the array as a linked list where index i points to index nums[i]. Since every value is in [1, n] and there are n+1 elements, there must be a cycle — and the entry point of that cycle is the duplicate number.

Let’s trace [1, 3, 4, 2, 2] (indices 0–4):

Index:  0  1  2  3  4
Value:  1  3  4  2  2

Treat as: node at index i has next pointer to index nums[i]

Start at index 0:
  0 -> nums[0]=1 -> nums[1]=3 -> nums[3]=2 -> nums[2]=4 -> nums[4]=2 -> nums[2]=4 -> ...
  Cycle: 2 -> 4 -> 2 -> 4 -> ...
  Entry point of cycle: index 2 (value 2 is the duplicate!)

The algorithm is exactly Floyd’s cycle detection:

1. Find where slow and fast pointers meet (inside the cycle).
2. Reset one pointer to the start.
3. Move both one step at a time until they meet — that meeting point is the cycle entry = the duplicate.

Why does resetting to start and walking at the same speed find the entry? It’s a mathematical property of Floyd’s algorithm: if the distance from start to cycle entry is F, and the cycle length is C, then after slow and fast meet inside the cycle, moving one pointer from start and one from the meeting point at the same speed, they converge at the cycle entry after F more steps.

Algorithm

1. Phase 1 — Find meeting point inside cycle:
   • slow = nums[0], fast = nums[0]
   • Move slow = nums[slow] and fast = nums[nums[fast]]
   • Repeat until slow == fast
2. Phase 2 — Find cycle entry:
   • Reset slow2 = nums[0] (start of the “linked list”)
   • Move slow = nums[slow] and slow2 = nums[slow2] (both one step)
   • Repeat until slow == slow2
3. Return slow (the cycle entry = duplicate).

Solution

def findDuplicate(nums):
    # Phase 1: Find the intersection point inside the cycle
    slow = nums[0]
    fast = nums[0]

    while True:
        slow = nums[slow]         # one step
        fast = nums[nums[fast]]   # two steps
        if slow == fast:
            break

    # Phase 2: Find the entry point of the cycle
    slow2 = nums[0]
    while slow != slow2:
        slow = nums[slow]
        slow2 = nums[slow2]

    return slow  # cycle entry = duplicate

# Test cases
print(findDuplicate([1, 3, 4, 2, 2]))  # 2
print(findDuplicate([3, 1, 3, 4, 2]))  # 3
print(findDuplicate([1, 1]))            # 1

# Trace for [1,3,4,2,2]:
# Index: 0 -> 1 -> 3 -> 2 -> 4 -> 2 (cycle!)
# Phase 1:
#   slow: 1, 3, 2, 4, 2, 4  ...
#   fast: 3, 4, 4, 4, ...  (fast loops in 2->4->2 cycle)
# They meet at 4 (or wherever in the cycle)
# Phase 2: slow2 starts at nums[0]=1, advances until meeting slow

# Larger test
import random
n = 10
nums = list(range(1, n+1)) + [random.randint(1, n)]  # add one duplicate
random.shuffle(nums)
print(f"nums={nums}, duplicate={findDuplicate(nums)}")

Complexity

• Time: O(n) — Floyd’s algorithm runs in linear time
• Space: O(1) — only two pointer variables

Common Pitfalls

Starting slow and fast at index 0 vs value nums[0]. Since index 0 is special (it’s our “entry node” to the linked list), we start both pointers at nums[0] — the first node we actually jump to. Don’t start at index 0 itself or you’ll treat 0 as part of the cycle incorrectly.

Modifying the array to mark visited nodes. A common approach uses negative marking or sorting, but the problem explicitly says you cannot modify the array. Floyd’s approach is the clean O(1) space solution that obeys this constraint.

Using the do-while pattern correctly. Phase 1 uses while True: ... if slow == fast: break because slow and fast start at the same place — we must move them at least once before checking equality.

Confusing index and value. At step i, we’re AT index i and we jump TO index nums[i]. The duplicate number is the index value that two different predecessors both point to — that’s the cycle entry.

Linked Lists

What if instead of buying reserved seats in a theatre (like an array), everyone just holds a ticket that says “the next person is in seat 42”? You don’t need a block of seats together — each person simply points to the next. That’s a linked list.

The Problem with Arrays

Arrays store data in a contiguous block of memory. That’s great for random access (arr[5] is instant), but terrible when you need to insert or delete in the middle — everything has to shuffle along.

flowchart LR
    subgraph Array["Array (contiguous memory)"]
        direction LR
        A0["[0] 10"] --- A1["[1] 20"] --- A2["[2] 30"] --- A3["[3] 40"]
    end

Insert 15 after index 0? Every element from index 1 onward must move one position to the right. With a million items, that’s a million moves — O(n).

The Linked List Solution

A linked list breaks free from contiguous memory. Each piece of data lives inside a node, and every node holds two things:

1. The value (the actual data)
2. A pointer (the memory address of the next node)

flowchart LR
    N1["Node\nvalue: 10\nnext: →"] --> N2["Node\nvalue: 20\nnext: →"] --> N3["Node\nvalue: 30\nnext: →"] --> N4["Node\nvalue: 40\nnext: null"]

Nodes can live anywhere in memory — they don’t need to be neighbours. Inserting a new node is just a matter of updating two pointers, regardless of list size.

Array vs Linked List at a Glance

flowchart LR
    subgraph LL["Linked List"]
        direction TB
        LL1["Prepend: O(1)"]
        LL2["Append (with tail): O(1)"]
        LL3["Access by index: O(n)"]
        LL4["Insert / Delete (with ref): O(1)"]
    end

    subgraph AR["Array"]
        direction TB
        AR1["Prepend: O(n)"]
        AR2["Append (amortised): O(1)"]
        AR3["Access by index: O(1)"]
        AR4["Insert / Delete (middle): O(n)"]
    end

Neither structure is universally better — the right choice depends on your access pattern.

Real-World Linked Lists

Linked lists show up everywhere you need cheap insertions and deletions at the edges:

• Music playlist — each song points to the next; skipping to the next track is just following one pointer
• Browser history — each page visited is a node; the back button follows prev pointers
• Blockchain — each block holds the hash (pointer) of the previous block, chaining them together
• Undo / redo in editors — each change is a node; undo walks backwards through the chain

What’s in This Section

Singly Linked Lists

Twitter’s original feed didn’t load all tweets at once. It kept a pointer to the latest tweet, and each tweet pointed to the one before it. That’s a singly linked list — a chain where every node knows only the next step forward, never back.

The Node: The Fundamental Building Block

Every singly linked list is made of nodes. A node is just a small object that holds two things: its value, and a pointer to the next node.

flowchart LR
    N["Node\n──────\nvalue: 42\nnext: ●"] --> M["Node\n──────\nvalue: 99\nnext: null"]

In Python:

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None   # points to the next Node, or None if last

# Create two nodes and link them manually
a = Node(42)
b = Node(99)
a.next = b  # a now points to b

print(a.value)        # 42
print(a.next.value)   # 99 — reached b through a's pointer
print(b.next)         # None — b is the last node

Chaining Nodes into a List

Once you have nodes, a list just needs to remember where the chain starts (the head) and where it ends (the tail).

flowchart LR
    HEAD(["head"]) --> N1["10"] --> N2["20"] --> N3["30"] --> N4["40"]
    TAIL(["tail"]) --> N4

Keeping a tail pointer is a small trick with a big payoff — it lets us append in O(1) instead of walking the entire chain every time.

Building a Full Singly Linked List

Let’s implement append, prepend, delete, search, and traverse step by step.

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None


class SinglyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
        self.length = 0

    # O(1) — tail pointer means no walking needed
    def append(self, value):
        node = Node(value)
        if self.head is None:
            self.head = self.tail = node
        else:
            self.tail.next = node
            self.tail = node
        self.length += 1

    # O(1) — just rewire the head pointer
    def prepend(self, value):
        node = Node(value)
        node.next = self.head
        self.head = node
        if self.tail is None:
            self.tail = node
        self.length += 1

    # O(n) — must walk to find the node before the target
    def delete(self, value):
        if self.head is None:
            return False
        if self.head.value == value:
            self.head = self.head.next
            if self.head is None:
                self.tail = None
            self.length -= 1
            return True
        cur = self.head
        while cur.next:
            if cur.next.value == value:
                if cur.next == self.tail:
                    self.tail = cur
                cur.next = cur.next.next
                self.length -= 1
                return True
            cur = cur.next
        return False

    # O(n) — scan from head until found or end
    def search(self, value):
        cur = self.head
        index = 0
        while cur:
            if cur.value == value:
                return index
            cur = cur.next
            index += 1
        return -1

    # O(n) — visit every node once
    def traverse(self):
        result = []
        cur = self.head
        while cur:
            result.append(cur.value)
            cur = cur.next
        return result


ll = SinglyLinkedList()
ll.append(20)
ll.append(30)
ll.append(40)
ll.prepend(10)

print("List:         ", ll.traverse())
print("Length:       ", ll.length)
print("Search 30:    index", ll.search(30))
print("Search 99:    index", ll.search(99))

ll.delete(30)
print("After delete 30:", ll.traverse())

ll.delete(10)   # deleting head
print("After delete 10:", ll.traverse())

What Happens During Prepend (O(1))

Prepending is instant — no matter how long the list is, it’s always just two pointer updates.

Before prepending 5:

flowchart LR
    HEAD(["head"]) --> N1["10"] --> N2["20"] --> N3["30"]
    TAIL(["tail"]) --> N3

After prepending 5:

flowchart LR
    HEAD(["head"]) --> N0["5"] --> N1["10"] --> N2["20"] --> N3["30"]
    TAIL(["tail"]) --> N3

Only the head pointer and the new node’s next change. Zero existing nodes are touched.

What Happens During Delete (O(n))

Deletion requires finding the node before the target — that’s the O(n) walk. Once found, it’s a single pointer update.

Before deleting 20:

flowchart LR
    HEAD(["head"]) --> N1["10"] --> N2["20"] --> N3["30"] --> N4["40"]
    TAIL(["tail"]) --> N4
    N1 -. "cur" .-> N2

After deleting 20:

flowchart LR
    HEAD(["head"]) --> N1["10"] --> N3["30"] --> N4["40"]
    TAIL(["tail"]) --> N4

Node 10’s next pointer skips over 20 and points directly to 30. The deleted node becomes unreachable and is garbage collected.

Time Complexity Summary

Without a tail pointer, append would require walking the entire list each time — making n appends cost O(n²) total. Always keep a tail.

Real-World: Undo History in Text Editors

When you type in a text editor, each keystroke or action is pushed onto a singly linked list. The “undo” operation pops from the head — O(1), instant, regardless of how many changes you’ve made. That’s why undo never slows down no matter how deep your history is.

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

class UndoHistory:
    """A minimal undo stack built on a singly linked list."""

    def __init__(self):
        self.head = None

    def push(self, action):
        node = Node(action)
        node.next = self.head
        self.head = node
        print(f"  Did: {action}")

    def undo(self):
        if self.head is None:
            print("  Nothing to undo.")
            return
        action = self.head.value
        self.head = self.head.next
        print(f"  Undid: {action}")

    def current_state(self):
        actions = []
        cur = self.head
        while cur:
            actions.append(cur.value)
            cur = cur.next
        return actions


history = UndoHistory()
history.push("type 'Hello'")
history.push("bold text")
history.push("change font size to 14")

print("History (most recent first):", history.current_state())
history.undo()
history.undo()
print("History after 2 undos:", history.current_state())

Doubly Linked Lists

A singly linked list is a one-way street. You can drive forward, but if you miss a turn you have to go all the way back to the start. A doubly linked list adds a second lane: every node knows both its next neighbour and its previous neighbour. Now you can travel in either direction.

The Doubly-Linked Node

Each node now carries three pieces of information:

flowchart LR
    P(["prev: ●"]) --> N["Node\n──────\nvalue: 42\nprev: ←\nnext: →"] --> Q(["next: ●"])

In Python:

class Node:
    def __init__(self, value):
        self.value = value
        self.prev = None   # points to the previous node
        self.next = None   # points to the next node

a = Node(10)
b = Node(20)
c = Node(30)

# Link forward
a.next = b
b.next = c

# Link backward
b.prev = a
c.prev = b

# Traverse forward
cur = a
while cur:
    print("forward:", cur.value)
    cur = cur.next

# Traverse backward from tail
cur = c
while cur:
    print("backward:", cur.value)
    cur = cur.prev

The Full Structure

With both head and tail pointers, we can enter the list from either end in O(1).

flowchart LR
    HEAD(["head"]) --> N1
    N1["10\n← null | 10 | →"] <--> N2["20\n← | 20 | →"] <--> N3["30\n← | 30 | →"] <--> N4["40\n← | 40 | null →"]
    TAIL(["tail"]) --> N4

Full Implementation

class Node:
    def __init__(self, value):
        self.value = value
        self.prev = None
        self.next = None


class DoublyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
        self.length = 0

    # O(1)
    def append(self, value):
        node = Node(value)
        if self.tail is None:
            self.head = self.tail = node
        else:
            node.prev = self.tail
            self.tail.next = node
            self.tail = node
        self.length += 1

    # O(1)
    def prepend(self, value):
        node = Node(value)
        if self.head is None:
            self.head = self.tail = node
        else:
            node.next = self.head
            self.head.prev = node
            self.head = node
        self.length += 1

    # O(1) when you already have the node reference
    def delete_node(self, node):
        if node.prev:
            node.prev.next = node.next
        else:
            self.head = node.next  # deleting head

        if node.next:
            node.next.prev = node.prev
        else:
            self.tail = node.prev  # deleting tail

        self.length -= 1
        return node.value

    # O(1) — tail pointer + prev pointer makes this instant
    def delete_tail(self):
        if self.tail is None:
            return None
        return self.delete_node(self.tail)

    # O(1)
    def delete_head(self):
        if self.head is None:
            return None
        return self.delete_node(self.head)

    def traverse_forward(self):
        result = []
        cur = self.head
        while cur:
            result.append(cur.value)
            cur = cur.next
        return result

    def traverse_backward(self):
        result = []
        cur = self.tail
        while cur:
            result.append(cur.value)
            cur = cur.prev
        return result


dll = DoublyLinkedList()
for v in [10, 20, 30, 40]:
    dll.append(v)

print("Forward: ", dll.traverse_forward())
print("Backward:", dll.traverse_backward())

dll.delete_tail()
print("After delete_tail:", dll.traverse_forward())

dll.delete_head()
print("After delete_head:", dll.traverse_forward())

Why O(1) Delete Is a Big Deal

In a singly linked list, deleting a node requires finding its predecessor — you have to walk from the head. With a doubly linked list, every node already knows its predecessor via prev. If you have a reference to the node, deletion is just four pointer updates, no searching.

Before deleting node 20:

flowchart LR
    HEAD(["head"]) --> N1["10"] <--> N2["20"] <--> N3["30"] <--> N4["40"]
    TAIL(["tail"]) --> N4

After deleting node 20:

flowchart LR
    HEAD(["head"]) --> N1["10"] <--> N3["30"] <--> N4["40"]
    TAIL(["tail"]) --> N4

Node 10’s next skips to 30, and node 30’s prev points back to 10. Done in O(1).

Forward and Backward Traversal in Action

class Node:
    def __init__(self, value):
        self.value = value
        self.prev = None
        self.next = None

class DoublyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None

    def append(self, value):
        node = Node(value)
        if self.tail is None:
            self.head = self.tail = node
        else:
            node.prev = self.tail
            self.tail.next = node
            self.tail = node

    def traverse_forward(self):
        result, cur = [], self.head
        while cur:
            result.append(cur.value)
            cur = cur.next
        return result

    def traverse_backward(self):
        result, cur = [], self.tail
        while cur:
            result.append(cur.value)
            cur = cur.prev
        return result


pages = DoublyLinkedList()
for page in ["google.com", "wikipedia.org", "python.org", "docs.python.org"]:
    pages.append(page)

print("Forward (browser history):", pages.traverse_forward())
print("Backward (hitting Back):  ", pages.traverse_backward())

Time Complexity Summary

The extra prev pointer costs one more memory reference per node. The payoff is O(1) deletion from any position (given the node) and bidirectional traversal.

Real-World Uses

Browser forward/back navigation is the textbook example. Each visited page is a node. The Back button follows prev pointers; the Forward button follows next pointers.

Python’s collections.deque is implemented as a doubly linked list under the hood. That’s why both appendleft/popleft and append/pop are O(1).

LRU Cache (Least Recently Used) is one of the most common interview problems. It combines a doubly linked list with a hash map: the list orders items by recency, and the hash map gives O(1) access to any node. When you access an item, you can unlink it from its current position and relink it at the front — all O(1) thanks to the prev pointer.

# Python's deque IS a doubly linked list
from collections import deque

browser_history = deque()

# Visit pages (append to right = go forward)
for page in ["home", "search", "article", "comments"]:
    browser_history.append(page)
    print(f"Visited: {page}")

print("\nHistory:", list(browser_history))

# Hit Back button (pop from right)
current = browser_history.pop()
print(f"\nBack from: {current}")
print("History:", list(browser_history))

# Go forward again
browser_history.append(current)
print(f"Forward to: {current}")
print("History:", list(browser_history))

Queues

Picture the checkout line at a supermarket. The first person to join the line is the first person to pay and leave. Nobody jumps the queue. Nobody gets served out of order. That’s a queue: First In, First Out — FIFO.

The FIFO Principle

A queue has exactly two operations:

• Enqueue — add an item to the back of the line
• Dequeue — remove an item from the front of the line

flowchart LR
    IN(["enqueue\n(add to back)"]) --> T["TAIL\n────\nTask C"]
    T <--> M["Task B"]
    M <--> H["HEAD\nTask A"]
    H --> OUT(["dequeue\n(remove from front)"])

The item that has waited the longest always gets served next. Items can never skip ahead.

Why a Doubly Linked List Is the Right Tool

You might wonder: why not just use a Python list? The problem is that removing from the front of a list (list.pop(0)) is O(n) — every remaining element must shift one position to the left. With a million items, that’s a million moves per dequeue.

A doubly linked list with a head pointer makes dequeue O(1): just redirect the head pointer to the second node. A tail pointer makes enqueue O(1) too.

Building a Queue from a Doubly Linked List

class Node:
    def __init__(self, value):
        self.value = value
        self.prev = None
        self.next = None


class Queue:
    def __init__(self):
        self.head = None   # front — dequeue from here
        self.tail = None   # back  — enqueue here
        self.length = 0

    def enqueue(self, value):
        """Add to the back. O(1)."""
        node = Node(value)
        if self.tail is None:
            self.head = self.tail = node
        else:
            node.prev = self.tail
            self.tail.next = node
            self.tail = node
        self.length += 1

    def dequeue(self):
        """Remove from the front. O(1)."""
        if self.head is None:
            return None
        value = self.head.value
        self.head = self.head.next
        if self.head is not None:
            self.head.prev = None
        else:
            self.tail = None   # queue is now empty
        self.length -= 1
        return value

    def peek(self):
        """Look at the front item without removing it. O(1)."""
        return self.head.value if self.head else None

    def is_empty(self):
        return self.length == 0

    def __repr__(self):
        items = []
        cur = self.head
        while cur:
            items.append(str(cur.value))
            cur = cur.next
        return "front -> [" + ", ".join(items) + "] <- back"


q = Queue()
print("Enqueuing tasks...")
for task in ["print report", "send email", "run backup"]:
    q.enqueue(task)
    print(f"  enqueued: {task!r:20s}  queue: {q}")

print("\nProcessing tasks...")
while not q.is_empty():
    task = q.dequeue()
    print(f"  processed: {task!r:20s}  queue: {q}")

Enqueue Step by Step

Starting with an empty queue, enqueue A, then B, then C:

After enqueue A:

flowchart LR
    HEAD(["head"]) --> NA["A"]
    TAIL(["tail"]) --> NA

After enqueue B:

flowchart LR
    HEAD(["head"]) --> NA["A"] <--> NB["B"]
    TAIL(["tail"]) --> NB

After enqueue C:

flowchart LR
    HEAD(["head"]) --> NA["A"] <--> NB["B"] <--> NC["C"]
    TAIL(["tail"]) --> NC

Dequeue Step by Step

Dequeue from the above queue (removes A):

flowchart LR
    HEAD(["head"]) --> NB["B"] <--> NC["C"]
    TAIL(["tail"]) --> NC
    GONE["A"] -. "removed" .-> NB

head now points to B. A is unreachable and gets garbage collected.

The Pythonic Way: collections.deque

Python’s standard library includes collections.deque — a battle-hardened doubly linked list (implemented in C). For production code, always prefer it over a hand-rolled queue.

from collections import deque

# Simulate a print spooler
print_spooler = deque()

# Users submit print jobs
print_spooler.append("Alice: budget.pdf")
print_spooler.append("Bob: slides.pptx")
print_spooler.append("Carol: report.docx")
print_spooler.append("Dave: logo.png")

print(f"Jobs in queue: {len(print_spooler)}")
print(f"Next to print: {print_spooler[0]}\n")

# Printer processes jobs one by one
while print_spooler:
    job = print_spooler.popleft()   # O(1) dequeue
    print(f"Printing: {job}")

print("\nAll jobs done. Spooler empty.")

deque also supports appendleft and pop for use as a stack or deque (double-ended queue), but when you only use append + popleft, it behaves as a pure FIFO queue.

Breadth-First Search: Queues in Algorithms

One of the most important uses of a queue is Breadth-First Search (BFS) — the algorithm that finds shortest paths in unweighted graphs. BFS explores all neighbours of the current node before moving deeper, and a queue is what enforces that “process closest nodes first” ordering.

from collections import deque

def bfs(graph, start):
    """
    Find the shortest number of hops from 'start' to every reachable node.
    Returns a dict: {node: distance_from_start}
    """
    visited = {start: 0}
    queue = deque([start])

    while queue:
        node = queue.popleft()          # process the oldest (closest) node
        for neighbour in graph[node]:
            if neighbour not in visited:
                visited[neighbour] = visited[node] + 1
                queue.append(neighbour) # explore it later

    return visited


# A simple social network: who follows whom
network = {
    "Alice": ["Bob", "Carol"],
    "Bob":   ["Alice", "Dave", "Eve"],
    "Carol": ["Alice", "Frank"],
    "Dave":  ["Bob"],
    "Eve":   ["Bob"],
    "Frank": ["Carol"],
}

distances = bfs(network, "Alice")
print("Degrees of separation from Alice:")
for person, hops in sorted(distances.items(), key=lambda x: x[1]):
    print(f"  {person}: {hops} hop(s)")

Real-World Queues

Time Complexity Summary

Fast and Slow Pointers

Imagine two runners on a circular track — one jogs at a steady pace while the other sprints at double the speed. If the track loops, the sprinter will eventually lap the jogger and they will meet. If the track is straight with a finish line, the sprinter just reaches the end first. This elegant insight is the heart of Floyd’s Cycle Detection Algorithm, and it works just as beautifully on linked lists.

The fast/slow pointer pattern (also called the “tortoise and hare” technique) is one of the most satisfying tricks in computer science: two pointers, one constraint, and a surprising number of problems solved.

How It Works

Two pointers start at the head of a linked list:

• Slow pointer — advances 1 node per step
• Fast pointer — advances 2 nodes per step

Their relative behaviour tells us everything:

graph LR
    A[Head] --> B[1] --> C[2] --> D[3] --> E[4] --> F[5]
    F --> C
    style A fill:#f5f5f5,stroke:#999
    style C fill:#ffd700,stroke:#e6b800
    style F fill:#ff6b6b,stroke:#cc0000

In the diagram above, node 5 points back to node 2, creating a cycle. The fast pointer enters the cycle first, keeps circling, and eventually collides with the slow pointer.

Problem 1: Detect a Cycle (Floyd’s Algorithm)

Real-world analogue: Memory leak detection — a garbage collector needs to know if a reference chain loops back on itself rather than terminating. Operating systems also use this to detect infinite loops in state machines.

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def has_cycle(head):
    slow = head
    fast = head

    while fast is not None and fast.next is not None:
        slow = slow.next        # 1 step
        fast = fast.next.next   # 2 steps

        if slow is fast:        # same object in memory
            return True

    return False  # fast reached the end — no cycle

# --- Build a list WITHOUT a cycle: 1 -> 2 -> 3 -> 4 -> 5 ---
nodes = [Node(i) for i in range(1, 6)]
for i in range(len(nodes) - 1):
    nodes[i].next = nodes[i + 1]

print("No cycle:", has_cycle(nodes[0]))   # False

# --- Build a list WITH a cycle: 1 -> 2 -> 3 -> 4 -> 5 -> (back to 2) ---
nodes[4].next = nodes[1]  # 5 points back to 2

print("With cycle:", has_cycle(nodes[0]))  # True

Why does this work? Once the fast pointer enters a cycle of length L, it is “trapped”. Each step the gap between fast and slow changes by 1 (fast gains 2, slow gains 1, so fast gains 1 on slow relative to the cycle). After at most L steps inside the cycle they are guaranteed to occupy the same node.

Complexity:

• Time: O(n) — fast pointer visits each node at most twice before either exiting or meeting slow
• Space: O(1) — just two pointer variables, no extra data structures

Problem 2: Find the Start of the Cycle

Knowing a cycle exists is useful. Knowing where it starts is even more useful — for example, finding the exact point of a circular reference in a dependency graph.

The mathematical trick: When slow and fast first meet, reset one pointer to the head and keep the other at the meeting point. Now advance both one step at a time. They will meet at the cycle’s entry node.

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def find_cycle_start(head):
    slow = head
    fast = head
    meeting_point = None

    # Phase 1: detect the cycle
    while fast is not None and fast.next is not None:
        slow = slow.next
        fast = fast.next.next
        if slow is fast:
            meeting_point = slow
            break

    if meeting_point is None:
        return None  # no cycle

    # Phase 2: find cycle entry
    pointer1 = head
    pointer2 = meeting_point

    while pointer1 is not pointer2:
        pointer1 = pointer1.next
        pointer2 = pointer2.next

    return pointer1  # both arrive at cycle start simultaneously

# Build: 0 -> 1 -> 2 -> 3 -> 4 -> 5 -> (back to 2)
nodes = [Node(i) for i in range(6)]
for i in range(len(nodes) - 1):
    nodes[i].next = nodes[i + 1]
nodes[5].next = nodes[2]  # cycle entry is node with value 2

start = find_cycle_start(nodes[0])
print("Cycle starts at node with value:", start.val)  # 2

# Build: 0 -> 1 -> 2 -> 3 -> (back to 0, full cycle)
nodes2 = [Node(i) for i in range(4)]
for i in range(len(nodes2) - 1):
    nodes2[i].next = nodes2[i + 1]
nodes2[3].next = nodes2[0]  # cycle entry is node with value 0

start2 = find_cycle_start(nodes2[0])
print("Cycle starts at node with value:", start2.val)  # 0

Why does Phase 2 work? Let F = distance from head to cycle start, C = cycle length, k = distance from cycle start to meeting point. It can be proven that F = C - k, which means a pointer from the head and a pointer from the meeting point, both moving one step at a time, will travel the same distance before reaching the cycle entry node.

Complexity:

• Time: O(n)
• Space: O(1)

Problem 3: Find the Middle of a Linked List

When fast reaches the end (None or the last node), slow is exactly at the middle. This is useful for merge sort on linked lists — split the list at the middle and sort each half recursively.

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def find_middle(head):
    slow = head
    fast = head

    # Fast moves 2 steps; when it can't, slow is at middle
    while fast is not None and fast.next is not None:
        slow = slow.next
        fast = fast.next.next

    return slow

def build_list(values):
    if not values:
        return None
    nodes = [Node(v) for v in values]
    for i in range(len(nodes) - 1):
        nodes[i].next = nodes[i + 1]
    return nodes[0]

def list_to_str(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    return " -> ".join(result)

# Odd length: 1 -> 2 -> 3 -> 4 -> 5
head_odd = build_list([1, 2, 3, 4, 5])
mid = find_middle(head_odd)
print(f"List: {list_to_str(head_odd)}")
print(f"Middle node: {mid.val}")   # 3

print()

# Even length: 1 -> 2 -> 3 -> 4
head_even = build_list([1, 2, 3, 4])
mid = find_middle(head_even)
print(f"List: {list_to_str(head_even)}")
print(f"Middle node: {mid.val}")   # 3  (second of the two middle nodes)

Complexity:

• Time: O(n)
• Space: O(1)

Problem 4: Check if a Linked List Length is Even or Odd

A neat side effect of the two-pointer dance: when fast exits the loop, its final position reveals the parity of the list’s length.

• If fast is None after the loop → fast took a full last step and “fell off” → even number of nodes
• If fast.next is None → fast landed on the last node exactly → odd number of nodes

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def is_length_even(head):
    fast = head
    while fast is not None and fast.next is not None:
        fast = fast.next.next
    # If fast is None, we exhausted the list evenly
    return fast is None

def build_list(values):
    if not values:
        return None
    nodes = [Node(v) for v in values]
    for i in range(len(nodes) - 1):
        nodes[i].next = nodes[i + 1]
    return nodes[0]

for length in [1, 2, 3, 4, 5, 6]:
    head = build_list(list(range(length)))
    parity = "even" if is_length_even(head) else "odd"
    print(f"Length {length}: {parity}")

Complexity:

• Time: O(n)
• Space: O(1)

Putting It All Together: Merge Sort on a Linked List

Here is a complete runnable merge sort that uses find_middle to split the list — the canonical real-world use of finding the middle node.

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def find_middle(head):
    slow = head
    fast = head
    prev = None
    while fast is not None and fast.next is not None:
        prev = slow
        slow = slow.next
        fast = fast.next.next
    if prev:
        prev.next = None  # split the list at the middle
    return slow

def merge(left, right):
    dummy = Node(0)
    tail = dummy
    while left and right:
        if left.val <= right.val:
            tail.next = left
            left = left.next
        else:
            tail.next = right
            right = right.next
        tail = tail.next
    tail.next = left if left else right
    return dummy.next

def merge_sort(head):
    if head is None or head.next is None:
        return head
    mid = find_middle(head)
    left = merge_sort(head)   # head's list is now cut at mid
    right = merge_sort(mid)
    return merge(left, right)

def build_list(values):
    if not values:
        return None
    nodes = [Node(v) for v in values]
    for i in range(len(nodes) - 1):
        nodes[i].next = nodes[i + 1]
    return nodes[0]

def list_to_python(head):
    result = []
    while head:
        result.append(head.val)
        head = head.next
    return result

import random
random.seed(42)
values = random.sample(range(100), 10)
print("Before:", values)

head = build_list(values)
sorted_head = merge_sort(head)
print("After: ", list_to_python(sorted_head))

Complexity Summary

Real-World Applications

• Memory leak detection — garbage collectors and tools like Valgrind track reference chains; a cycle means an object can never be freed.
• Infinite loop detection in state machines — a finite state machine that cycles indefinitely without reaching an exit state is broken; fast/slow can detect this in O(states) time.
• Merge sort on linked lists — finding the midpoint without knowing the length in advance is exactly what find_middle does; used in real standard library implementations.
• Network packet routing — detecting routing loops where a packet bounces between routers infinitely.
• Functional programming — lazy infinite lists and stream processing use cycle detection to identify when a generator has looped back.

Linked List Problems

Practice problems for the Linked Lists section, covering pointer manipulation, cycle detection, and cache-style designs.

Reverse Linked List

Difficulty: Easy Source: NeetCode

Problem

Given the head of a singly linked list, reverse the list, and return the reversed list.

Example 1: Input: head = [1,2,3,4,5] Output: [5,4,3,2,1]

Example 2: Input: head = [1,2] Output: [2,1]

Constraints:

• The number of nodes in the list is in the range [0, 5000]
• -5000 <= Node.val <= 5000

Prerequisites

Before attempting this problem, you should be comfortable with:

• Linked List Traversal — walking a linked list node by node using .next
• Pointer Manipulation — re-assigning .next references to change list structure

1. Brute Force / Naive Approach

Intuition

The simplest idea is to not think about pointers at all. Just walk the list, collect all the values into a Python list, reverse that list, then rebuild a brand new linked list. It wastes memory but it’s easy to reason about and a great starting point.

Algorithm

1. Walk the original list and collect all node values into a Python list.
2. Reverse the Python list.
3. Build a new linked list from the reversed values and return its head.

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    cur = head
    for v in values[1:]:
        cur.next = ListNode(v)
        cur = cur.next
    return head

def print_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" -> ".join(result) if result else "None")

# Brute force: collect values, rebuild reversed
def reverseList_brute(head):
    values = []
    cur = head
    while cur:
        values.append(cur.val)
        cur = cur.next

    values.reverse()

    dummy = ListNode(0)
    cur = dummy
    for v in values:
        cur.next = ListNode(v)
        cur = cur.next
    return dummy.next

# Test cases
head = build_list([1, 2, 3, 4, 5])
print("Input:  ", end=""); print_list(head)
result = reverseList_brute(head)
print("Output: ", end=""); print_list(result)  # 5 -> 4 -> 3 -> 2 -> 1

head2 = build_list([1, 2])
result2 = reverseList_brute(head2)
print("Output: ", end=""); print_list(result2)  # 2 -> 1

head3 = build_list([])
result3 = reverseList_brute(head3)
print("Output: ", end=""); print_list(result3)  # None

Complexity

• Time: O(n) — two passes over the list
• Space: O(n) — storing all values in a Python list

2. Iterative In-Place (Optimal)

Intuition

Instead of collecting values, we can flip the .next pointers directly as we walk the list. We keep track of two pointers: prev (starts as None) and curr (starts at head). At each step, we save curr.next, point curr.next back to prev, then advance both pointers forward. When curr falls off the end, prev is the new head.

Initial:  None <- 1 -> 2 -> 3 -> 4 -> 5
After 1:  None <- 1 <- 2    3 -> 4 -> 5
After 2:  None <- 1 <- 2 <- 3    4 -> 5
...
Final:    None <- 1 <- 2 <- 3 <- 4 <- 5

Algorithm

1. Initialize prev = None and curr = head.
2. While curr is not None: a. Save next_node = curr.next. b. Point curr.next = prev (reverse the arrow). c. Move prev = curr. d. Move curr = next_node.
3. Return prev as the new head.

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    cur = head
    for v in values[1:]:
        cur.next = ListNode(v)
        cur = cur.next
    return head

def print_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" -> ".join(result) if result else "None")

def reverseList(head):
    prev = None
    curr = head
    while curr:
        next_node = curr.next  # save next before we overwrite it
        curr.next = prev       # flip the pointer
        prev = curr            # advance prev
        curr = next_node       # advance curr
    return prev  # prev is now the new head

# Test cases
head = build_list([1, 2, 3, 4, 5])
print("Input:  ", end=""); print_list(head)
result = reverseList(head)
print("Output: ", end=""); print_list(result)  # 5 -> 4 -> 3 -> 2 -> 1

head2 = build_list([1, 2])
print("Output: ", end=""); print_list(reverseList(head2))  # 2 -> 1

print("Output: ", end=""); print_list(reverseList(None))   # None

Complexity

• Time: O(n) — single pass
• Space: O(1) — only two pointer variables

3. Recursive Approach

Intuition

Recursion is elegant here: to reverse a list, reverse everything after the head, then make the second node point back to the head and detach the head’s .next. The base case is an empty list or single node — that’s already reversed.

Think of it this way: if we call reverseList([2,3,4,5]) and it gives us back 5->4->3->2, then 2.next still points to 3. We want 3 to point back to 1… actually we want head.next.next = head and head.next = None.

Algorithm

1. Base case: if head is None or head.next is None, return head.
2. Recurse on head.next — this reverses the rest and returns the new head.
3. Set head.next.next = head (make the node after head point back to head).
4. Set head.next = None (detach head from the old chain).
5. Return the new head from step 2.

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    cur = head
    for v in values[1:]:
        cur.next = ListNode(v)
        cur = cur.next
    return head

def print_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" -> ".join(result) if result else "None")

def reverseList_recursive(head):
    # Base case: empty list or single node
    if not head or not head.next:
        return head

    # Reverse the rest of the list
    new_head = reverseList_recursive(head.next)

    # head.next is now the tail of the reversed sublist
    # Make it point back to head
    head.next.next = head
    head.next = None  # head becomes the new tail

    return new_head

# Test cases
head = build_list([1, 2, 3, 4, 5])
result = reverseList_recursive(head)
print("Output: ", end=""); print_list(result)  # 5 -> 4 -> 3 -> 2 -> 1

head2 = build_list([1, 2])
print("Output: ", end=""); print_list(reverseList_recursive(head2))  # 2 -> 1

print("Output: ", end=""); print_list(reverseList_recursive(None))   # None

Complexity

• Time: O(n) — visits every node once
• Space: O(n) — call stack depth equals list length

Common Pitfalls

Forgetting to save curr.next before overwriting it. Once you do curr.next = prev, you’ve lost your reference to the rest of the list. Always save next_node = curr.next first.

Returning curr instead of prev. When the loop ends, curr is None and prev is the last node you processed — which is the new head. Returning curr gives back None.

Forgetting head.next = None in the recursive approach. Without this, the original head still points forward, creating a cycle in your result.

Merge Two Sorted Lists

Difficulty: Easy Source: NeetCode

Problem

You are given the heads of two sorted linked lists list1 and list2. Merge the two lists into one sorted list. The list should be made by splicing together the nodes of the first two lists. Return the head of the merged linked list.

Example 1: Input: list1 = [1,2,4], list2 = [1,3,4] Output: [1,1,2,3,4,4]

Example 2: Input: list1 = [], list2 = [] Output: []

Constraints:

• The number of nodes in both lists is in the range [0, 50]
• -100 <= Node.val <= 100
• Both list1 and list2 are sorted in non-decreasing order

Prerequisites

Before attempting this problem, you should be comfortable with:

• Linked List Traversal — walking a list node by node using .next
• Dummy Head Trick — using a sentinel node to simplify edge cases in list construction
• Two-Pointer Technique — advancing two pointers independently based on a comparison

1. Brute Force / Naive Approach

Intuition

Forget about the linked list structure for a moment. Collect all values from both lists into a Python list, sort it, then rebuild a linked list. It’s straightforward but wastes memory and ignores the fact that both inputs are already sorted.

Algorithm

1. Walk list1 and collect all values.
2. Walk list2 and collect all values.
3. Sort the combined values.
4. Build a new linked list from the sorted values and return its head.

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    cur = head
    for v in values[1:]:
        cur.next = ListNode(v)
        cur = cur.next
    return head

def print_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" -> ".join(result) if result else "None")

def mergeTwoLists_brute(list1, list2):
    values = []
    cur = list1
    while cur:
        values.append(cur.val)
        cur = cur.next
    cur = list2
    while cur:
        values.append(cur.val)
        cur = cur.next

    values.sort()

    dummy = ListNode(0)
    cur = dummy
    for v in values:
        cur.next = ListNode(v)
        cur = cur.next
    return dummy.next

# Test cases
l1 = build_list([1, 2, 4])
l2 = build_list([1, 3, 4])
print("Output: ", end=""); print_list(mergeTwoLists_brute(l1, l2))  # 1->1->2->3->4->4

print("Output: ", end=""); print_list(mergeTwoLists_brute(None, None))  # None

l3 = build_list([])
l4 = build_list([0])
print("Output: ", end=""); print_list(mergeTwoLists_brute(l3, l4))  # 0

Complexity

• Time: O((m+n) log(m+n)) — sorting all values
• Space: O(m+n) — storing all values

2. Iterative with Dummy Head (Optimal)

Intuition

Since both lists are already sorted, we can merge them in one pass using the classic merge step from merge sort. We compare the heads of both lists, pick the smaller one, attach it to our result, and advance that list’s pointer. A dummy head node makes it easy to handle the “empty result” edge case — we just return dummy.next at the end.

list1: 1 -> 2 -> 4
list2: 1 -> 3 -> 4

Step 1: compare 1 vs 1 → pick list1's 1, result: 1
Step 2: compare 2 vs 1 → pick list2's 1, result: 1 -> 1
Step 3: compare 2 vs 3 → pick list1's 2, result: 1 -> 1 -> 2
Step 4: compare 4 vs 3 → pick list2's 3, result: 1 -> 1 -> 2 -> 3
Step 5: compare 4 vs 4 → pick list1's 4, result: 1 -> 1 -> 2 -> 3 -> 4
Step 6: list1 exhausted → append rest of list2 (just 4)
Final:  1 -> 1 -> 2 -> 3 -> 4 -> 4

Algorithm

1. Create a dummy sentinel node and set cur = dummy.
2. While both list1 and list2 are not None:
   • If list1.val <= list2.val, attach list1 and advance list1.
   • Otherwise, attach list2 and advance list2.
   • Advance cur.
3. Attach whichever list still has remaining nodes.
4. Return dummy.next.

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    cur = head
    for v in values[1:]:
        cur.next = ListNode(v)
        cur = cur.next
    return head

def print_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" -> ".join(result) if result else "None")

def mergeTwoLists(list1, list2):
    dummy = ListNode(0)  # sentinel node
    cur = dummy

    while list1 and list2:
        if list1.val <= list2.val:
            cur.next = list1
            list1 = list1.next
        else:
            cur.next = list2
            list2 = list2.next
        cur = cur.next

    # Attach any remaining nodes (at most one list has leftover)
    cur.next = list1 if list1 else list2

    return dummy.next

# Test cases
l1 = build_list([1, 2, 4])
l2 = build_list([1, 3, 4])
print("Output: ", end=""); print_list(mergeTwoLists(l1, l2))  # 1->1->2->3->4->4

print("Output: ", end=""); print_list(mergeTwoLists(None, None))  # None

l3 = build_list([])
l4 = build_list([0])
print("Output: ", end=""); print_list(mergeTwoLists(l3, l4))  # 0

l5 = build_list([1, 3, 5])
l6 = build_list([2, 4, 6])
print("Output: ", end=""); print_list(mergeTwoLists(l5, l6))  # 1->2->3->4->5->6

Complexity

• Time: O(m+n) — single pass through both lists
• Space: O(1) — we reuse existing nodes, only allocate the dummy node

Common Pitfalls

Not handling the case when one list is exhausted early. The while loop exits as soon as either list is empty. You need cur.next = list1 if list1 else list2 to attach what’s left — don’t try to loop again.

Forgetting the dummy node. Without a dummy, you’d need special-case logic for setting the initial head. The dummy node makes the code uniform — every node is added via cur.next.

Using <= vs < in the comparison. Using <= means when values are equal, we prefer list1. This is fine for correctness but matters if you’re asked to be stable — either way, both lists get fully consumed.

Linked List Cycle

Difficulty: Easy Source: NeetCode

Problem

Given head, the head of a linked list, determine if the linked list has a cycle in it. There is a cycle if some node in the list can be reached again by continuously following the next pointer. Internally, pos is used to denote the index of the node that tail’s next pointer is connected to (0-indexed). Note that pos is not passed as a parameter. Return true if there is a cycle in the linked list, otherwise return false.

Example 1: Input: head = [3,2,0,-4], pos = 1 Output: true

Example 2: Input: head = [1,2], pos = 0 Output: false

Constraints:

• The number of nodes in the list is in the range [0, 10^4]
• -10^5 <= Node.val <= 10^5
• pos is -1 or a valid index in the linked list

Prerequisites

Before attempting this problem, you should be comfortable with:

• Linked List Traversal — following .next pointers through a list
• Hash Sets — O(1) lookup for tracking visited elements
• Two-Pointer Technique — using slow and fast pointers moving at different speeds

1. Brute Force / Naive Approach

Intuition

Keep a hash set of every node we’ve visited. As we walk the list, if we ever encounter a node we’ve already seen, there must be a cycle. If we reach None, the list is finite and has no cycle. The catch: we’re storing node references (not values, since values can repeat) in the set.

Algorithm

1. Initialize an empty set visited.
2. Walk the list with pointer cur.
3. If cur is already in visited, return True.
4. Add cur to visited and advance to cur.next.
5. If the loop ends (we hit None), return False.

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list_with_cycle(values, pos):
    """Build a linked list with an optional cycle.
    pos = -1 means no cycle; otherwise tail.next points to node at index pos."""
    if not values:
        return None
    nodes = [ListNode(v) for v in values]
    for i in range(len(nodes) - 1):
        nodes[i].next = nodes[i + 1]
    if pos != -1:
        nodes[-1].next = nodes[pos]  # create cycle
    return nodes[0]

def hasCycle_brute(head):
    visited = set()
    cur = head
    while cur:
        if cur in visited:
            return True
        visited.add(cur)
        cur = cur.next
    return False

# Test cases
head1 = build_list_with_cycle([3, 2, 0, -4], pos=1)
print(hasCycle_brute(head1))  # True

head2 = build_list_with_cycle([1, 2], pos=0)
print(hasCycle_brute(head2))  # True

head3 = build_list_with_cycle([1], pos=-1)
print(hasCycle_brute(head3))  # False

head4 = build_list_with_cycle([3, 2, 0, -4], pos=-1)
print(hasCycle_brute(head4))  # False

Complexity

• Time: O(n) — visit each node at most once
• Space: O(n) — storing all visited nodes in the set

2. Floyd’s Cycle Detection (Optimal)

Intuition

This is the classic “tortoise and hare” algorithm. Use two pointers: slow moves one step at a time, fast moves two steps at a time. If there’s no cycle, fast will hit None and we’re done. If there is a cycle, both pointers end up going around the loop — and since fast is lapping slow, they will eventually meet at the same node.

Think of it like a circular running track: if two runners start at the same point and one runs twice as fast, the faster runner will eventually lap the slower one and they’ll be at the same position again.

No cycle:
slow: 1 -> 2 -> 3 -> None  (fast gets to None first, exit)

With cycle [3,2,0,-4], cycle at index 1:
Step 0: slow=3, fast=3
Step 1: slow=2, fast=0
Step 2: slow=0, fast=2
Step 3: slow=-4, fast=-4  <-- they meet! cycle confirmed

Algorithm

1. Initialize slow = head and fast = head.
2. While fast and fast.next are not None:
   • Move slow one step: slow = slow.next.
   • Move fast two steps: fast = fast.next.next.
   • If slow == fast, return True.
3. Return False (fast reached the end, no cycle).

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list_with_cycle(values, pos):
    if not values:
        return None
    nodes = [ListNode(v) for v in values]
    for i in range(len(nodes) - 1):
        nodes[i].next = nodes[i + 1]
    if pos != -1:
        nodes[-1].next = nodes[pos]
    return nodes[0]

def hasCycle(head):
    slow = head
    fast = head

    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            return True

    return False

# Test cases
head1 = build_list_with_cycle([3, 2, 0, -4], pos=1)
print(hasCycle(head1))  # True

head2 = build_list_with_cycle([1, 2], pos=0)
print(hasCycle(head2))  # True

head3 = build_list_with_cycle([1], pos=-1)
print(hasCycle(head3))  # False

head4 = build_list_with_cycle([3, 2, 0, -4], pos=-1)
print(hasCycle(head4))  # False

head5 = build_list_with_cycle([], pos=-1)
print(hasCycle(head5))  # False

Complexity

• Time: O(n) — both pointers traverse at most O(n) steps before meeting or exiting
• Space: O(1) — only two pointer variables, no extra data structures

Common Pitfalls

Checking slow == fast before moving them. Both start at head, so they’re equal initially — don’t check before moving or you’ll always return True. The check should be inside the loop after advancing.

Checking fast.next in the while condition. You need fast and fast.next because you’re jumping two steps: fast.next.next. If you only check fast, you’ll get an AttributeError when fast is the last node and you try to access fast.next.next.

Storing node values instead of node references in the brute force. Values can repeat! [1, 1, 1] with no cycle would incorrectly return True. Always add the node object itself to the set, not its .val.

Reorder List

Difficulty: Medium Source: NeetCode

Problem

You are given the head of a singly linked-list: L0 → L1 → … → Ln-1 → Ln. Reorder it to: L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → … You may not modify the values in the list’s nodes. Only nodes themselves may be changed.

Example 1: Input: head = [1,2,3,4] Output: [1,4,2,3]

Example 2: Input: head = [1,2,3,4,5] Output: [1,5,2,4,3]

Constraints:

• The number of nodes in the list is in the range [1, 5 * 10^4]
• 1 <= Node.val <= 1000

Prerequisites

Before attempting this problem, you should be comfortable with:

• Slow/Fast Pointer (Middle of List) — finding the midpoint of a linked list
• Reversing a Linked List — in-place pointer reversal (see problem 1)
• Merging Two Lists — interleaving nodes from two lists

1. Brute Force / Naive Approach

Intuition

Collect all the nodes into a Python list (by reference, not by value). Then use two pointers — one from the front, one from the back — to pick nodes alternately and re-link them. This avoids the three-step trick but uses O(n) extra space.

Algorithm

1. Collect all nodes into a Python list nodes.
2. Use left = 0 and right = len(nodes) - 1 pointers.
3. While left < right:
   • Link nodes[left].next = nodes[right].
   • Advance left.
   • If left == right, break (odd-length middle node).
   • Link nodes[right].next = nodes[left].
   • Advance right backward.
4. Set nodes[left].next = None (terminate the list).

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    cur = head
    for v in values[1:]:
        cur.next = ListNode(v)
        cur = cur.next
    return head

def print_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" -> ".join(result) if result else "None")

def reorderList_brute(head):
    if not head:
        return

    nodes = []
    cur = head
    while cur:
        nodes.append(cur)
        cur = cur.next

    left, right = 0, len(nodes) - 1
    while left < right:
        nodes[left].next = nodes[right]
        left += 1
        if left == right:
            break
        nodes[right].next = nodes[left]
        right -= 1

    nodes[left].next = None  # terminate

# Test cases
head = build_list([1, 2, 3, 4])
reorderList_brute(head)
print("Output: ", end=""); print_list(head)  # 1 -> 4 -> 2 -> 3

head2 = build_list([1, 2, 3, 4, 5])
reorderList_brute(head2)
print("Output: ", end=""); print_list(head2)  # 1 -> 5 -> 2 -> 4 -> 3

head3 = build_list([1])
reorderList_brute(head3)
print("Output: ", end=""); print_list(head3)  # 1

Complexity

• Time: O(n) — one pass to collect, one pass to re-link
• Space: O(n) — storing all node references

2. Three-Step In-Place (Optimal)

Intuition

The key insight is that the reordering pattern is: take from the front, take from the back, alternate. That means we’re interleaving the first half with the reversed second half. So the plan is:

1. Find the middle using slow/fast pointers.
2. Reverse the second half in-place.
3. Merge the two halves by interleaving.

Let’s trace [1,2,3,4,5]:

Step 1 - Find middle:
slow/fast start at 1
slow=2, fast=3
slow=3, fast=5 (fast.next is None, stop)
Middle = node 3

First half:  1 -> 2 -> 3 -> None
Second half: 4 -> 5 -> None

Step 2 - Reverse second half:
4 -> 5 -> None  becomes  5 -> 4 -> None

Step 3 - Merge:
Take 1 from first, take 5 from second
Take 2 from first, take 4 from second
Take 3 from first (middle, second is exhausted)
Result: 1 -> 5 -> 2 -> 4 -> 3

Algorithm

1. Find the middle node using slow/fast pointers.
2. Split the list: mid.next = None terminates the first half.
3. Reverse the second half.
4. Merge first and second halves by interleaving: take one from each, alternating, until one is exhausted.

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    cur = head
    for v in values[1:]:
        cur.next = ListNode(v)
        cur = cur.next
    return head

def print_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" -> ".join(result) if result else "None")

def reorderList(head):
    if not head or not head.next:
        return

    # Step 1: Find the middle using slow/fast pointers
    slow, fast = head, head
    while fast.next and fast.next.next:
        slow = slow.next
        fast = fast.next.next
    # slow is now the middle node

    # Step 2: Reverse the second half
    second = slow.next
    slow.next = None  # cut the list in half
    prev = None
    while second:
        tmp = second.next
        second.next = prev
        prev = second
        second = tmp
    second = prev  # second now points to the reversed second half

    # Step 3: Merge the two halves by interleaving
    first = head
    while second:
        tmp1 = first.next
        tmp2 = second.next
        first.next = second
        second.next = tmp1
        first = tmp1
        second = tmp2

# Test cases
head = build_list([1, 2, 3, 4])
reorderList(head)
print("Output: ", end=""); print_list(head)  # 1 -> 4 -> 2 -> 3

head2 = build_list([1, 2, 3, 4, 5])
reorderList(head2)
print("Output: ", end=""); print_list(head2)  # 1 -> 5 -> 2 -> 4 -> 3

head3 = build_list([1])
reorderList(head3)
print("Output: ", end=""); print_list(head3)  # 1

head4 = build_list([1, 2])
reorderList(head4)
print("Output: ", end=""); print_list(head4)  # 1 -> 2

Complexity

• Time: O(n) — three linear passes (find middle, reverse, merge)
• Space: O(1) — all operations are in-place

Common Pitfalls

Wrong middle for even-length lists. For [1,2,3,4], the middle should be node 2 (so first half is [1,2] and second is [3,4]). Use fast.next and fast.next.next as the condition — this stops slow at node 2 for even lists.

Forgetting to cut the list in half. If you don’t set slow.next = None, the first half still connects into the second half. After reversing the second half you’ll have a messy loop.

Losing pointers during the merge. During interleaving you overwrite .next pointers. Always save first.next and second.next into temporaries before re-linking.

Remove Nth Node From End of List

Difficulty: Medium Source: NeetCode

Problem

Given the head of a linked list, remove the nth node from the end of the list and return its head.

Example 1: Input: head = [1,2,3,4,5], n = 2 Output: [1,2,3,5]

Example 2: Input: head = [1], n = 1 Output: []

Example 3: Input: head = [1,2], n = 1 Output: [1]

Constraints:

• The number of nodes in the list is sz
• 1 <= sz <= 30
• 0 <= Node.val <= 100
• 1 <= n <= sz

Prerequisites

Before attempting this problem, you should be comfortable with:

• Linked List Traversal — walking a list and counting nodes
• Two-Pointer Technique — maintaining a gap between two pointers
• Dummy Head Trick — using a sentinel node to handle edge cases like removing the head

1. Brute Force / Naive Approach

Intuition

First, figure out the total length of the list. Then the nth node from the end is at position length - n from the start (0-indexed). Walk to that position and remove it. Straightforward and easy to reason about, but requires two full passes.

Algorithm

1. Walk the list to get its length L.
2. The target node is at index L - n (0-indexed from head).
3. Walk to index L - n - 1 (the node just before the target).
4. Skip the target: prev.next = prev.next.next.
5. Handle the special case where the target is the head itself (L - n == 0).

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    cur = head
    for v in values[1:]:
        cur.next = ListNode(v)
        cur = cur.next
    return head

def print_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" -> ".join(result) if result else "None")

def removeNthFromEnd_brute(head, n):
    # First pass: get length
    length = 0
    cur = head
    while cur:
        length += 1
        cur = cur.next

    # The node to remove is at index (length - n) from the start (0-indexed)
    target_idx = length - n

    # Special case: removing the head
    if target_idx == 0:
        return head.next

    # Second pass: walk to node just before target
    cur = head
    for _ in range(target_idx - 1):
        cur = cur.next

    cur.next = cur.next.next  # skip the target node
    return head

# Test cases
head = build_list([1, 2, 3, 4, 5])
print("Output: ", end=""); print_list(removeNthFromEnd_brute(head, 2))  # 1->2->3->5

head2 = build_list([1])
print("Output: ", end=""); print_list(removeNthFromEnd_brute(head2, 1))  # None

head3 = build_list([1, 2])
print("Output: ", end=""); print_list(removeNthFromEnd_brute(head3, 1))  # 1

Complexity

• Time: O(n) — two passes over the list
• Space: O(1) — no extra data structures

2. Two-Pointer One-Pass (Optimal)

Intuition

We can do this in a single pass by maintaining a gap of exactly n nodes between two pointers. Here’s the trick:

• Advance the fast pointer n steps ahead.
• Then move both slow and fast together until fast.next is None.
• At that point, slow is sitting just before the node to remove.

Using a dummy head means we never have to special-case removing the actual head node.

head = [1, 2, 3, 4, 5], n = 2

dummy -> 1 -> 2 -> 3 -> 4 -> 5 -> None
slow = dummy, fast = dummy

Advance fast 2 steps:
fast = 2  (dummy, 1, 2 -- that's 2 steps from dummy)

Move both until fast.next is None:
slow=1, fast=3
slow=2, fast=4
slow=3, fast=5  (fast.next is None, stop)

slow.next is 4 (the 2nd from end) -- remove it:
slow.next = slow.next.next  →  3 -> 5

Result: 1 -> 2 -> 3 -> 5

Algorithm

1. Create a dummy node pointing to head. Set slow = dummy and fast = dummy.
2. Advance fast exactly n steps forward.
3. Move both slow and fast one step at a time until fast.next is None.
4. Remove slow.next: slow.next = slow.next.next.
5. Return dummy.next.

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    cur = head
    for v in values[1:]:
        cur.next = ListNode(v)
        cur = cur.next
    return head

def print_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" -> ".join(result) if result else "None")

def removeNthFromEnd(head, n):
    dummy = ListNode(0, head)  # dummy.next = head
    slow = dummy
    fast = dummy

    # Advance fast by n steps
    for _ in range(n):
        fast = fast.next

    # Move both until fast.next is None
    while fast.next:
        slow = slow.next
        fast = fast.next

    # slow.next is the node to remove
    slow.next = slow.next.next

    return dummy.next

# Test cases
head = build_list([1, 2, 3, 4, 5])
print("Output: ", end=""); print_list(removeNthFromEnd(head, 2))  # 1->2->3->5

head2 = build_list([1])
print("Output: ", end=""); print_list(removeNthFromEnd(head2, 1))  # None

head3 = build_list([1, 2])
print("Output: ", end=""); print_list(removeNthFromEnd(head3, 1))  # 1

head4 = build_list([1, 2])
print("Output: ", end=""); print_list(removeNthFromEnd(head4, 2))  # 2 (remove head)

head5 = build_list([1, 2, 3, 4, 5])
print("Output: ", end=""); print_list(removeNthFromEnd(head5, 5))  # 2->3->4->5 (remove head)

Complexity

• Time: O(sz) — single pass
• Space: O(1) — only pointer variables

Common Pitfalls

Not using a dummy node and forgetting the head-removal edge case. If the list has only one node and n=1, the result should be None. Without a dummy, you need a special if branch. The dummy node makes slow always point to the node before the one to delete, even when deleting the head.

Advancing fast by n+1 instead of n. Some formulations advance fast by n+1 from a dummy start and then stop when fast is None. Both work, but they’re different — be consistent. In our approach: advance by n, then stop when fast.next is None.

Off-by-one in the gap. The gap between slow and fast should be such that when fast reaches the last node (not past it), slow is at the node before the one to remove. Trace through a small example to verify your gap is correct.

Copy List With Random Pointer

Difficulty: Medium Source: NeetCode

Problem

A linked list of length n is given such that each node contains an additional random pointer, which could point to any node in the list, or null. Construct a deep copy of the list. The deep copy should consist of exactly n brand new nodes, where each new node has its value set to the value of its corresponding original node. Both the next and random pointer of the new nodes should point to new nodes in the copied list such that the pointers represent the same list state. None of the pointers in the new list should point to nodes in the original list. Return the head of the copied linked list.

Example 1: Input: head = [[7,null],[13,0],[11,4],[10,2],[1,0]] Output: [[7,null],[13,0],[11,4],[10,2],[1,0]]

Example 2: Input: head = [[1,1],[2,1]] Output: [[1,1],[2,1]]

Constraints:

• 0 <= n <= 1000
• -10^4 <= Node.val <= 10^4
• Node.random is null or pointing to some node in the linked list

Prerequisites

Before attempting this problem, you should be comfortable with:

• Hash Maps — mapping old nodes to their new copies for O(1) lookup
• Two-Pass Traversal — first create nodes, then wire up pointers
• Deep vs Shallow Copy — understanding that pointers must point to new nodes, not original ones

1. Hash Map Approach (Standard)

Intuition

The challenge here is the random pointer — it can point anywhere in the list, including backwards. If we try to copy in one pass, we might reference a copy that doesn’t exist yet.

The clean solution: two passes using a hash map that maps each original node to its newly created copy.

• Pass 1: Walk the original list and create a fresh copy of each node, storing the mapping {original: copy}.
• Pass 2: Walk again and wire up .next and .random for each copy using the map.

Since the map gives us copy_of[original.next] and copy_of[original.random] in O(1), this is efficient.

Algorithm

1. Edge case: if head is None, return None.
2. Create a dictionary old_to_new = {}.
3. First pass — create all copy nodes: for each node in the original list, create new_node = Node(node.val) and store old_to_new[node] = new_node.
4. Second pass — wire pointers: for each node in the original list:
   • old_to_new[node].next = old_to_new.get(node.next)
   • old_to_new[node].random = old_to_new.get(node.random)
5. Return old_to_new[head].

Solution

class Node:
    def __init__(self, val=0, next=None, random=None):
        self.val = val
        self.next = next
        self.random = random

def build_list(pairs):
    """Build list from [(val, random_index_or_None), ...]"""
    if not pairs:
        return None
    nodes = [Node(val) for val, _ in pairs]
    for i in range(len(nodes) - 1):
        nodes[i].next = nodes[i + 1]
    for i, (_, rand_idx) in enumerate(pairs):
        if rand_idx is not None:
            nodes[i].random = nodes[rand_idx]
    return nodes[0]

def print_list(head):
    # Build node->index mapping to display random pointer indices
    node_index = {}
    cur = head
    idx = 0
    while cur:
        node_index[cur] = idx
        cur = cur.next
        idx += 1
    cur = head
    result = []
    while cur:
        rand_idx = node_index[cur.random] if cur.random else None
        result.append(f"[{cur.val}, {rand_idx}]")
        cur = cur.next
    print(" -> ".join(result) if result else "None")

def copyRandomList(head):
    if not head:
        return None

    old_to_new = {}

    # Pass 1: create all copy nodes
    cur = head
    while cur:
        old_to_new[cur] = Node(cur.val)
        cur = cur.next

    # Pass 2: wire up next and random pointers
    cur = head
    while cur:
        if cur.next:
            old_to_new[cur].next = old_to_new[cur.next]
        if cur.random:
            old_to_new[cur].random = old_to_new[cur.random]
        cur = cur.next

    return old_to_new[head]

# Test cases
head1 = build_list([(7, None), (13, 0), (11, 4), (10, 2), (1, 0)])
print("Original: ", end=""); print_list(head1)
copy1 = copyRandomList(head1)
print("Copy:     ", end=""); print_list(copy1)
print("Are they different objects?", head1 is not copy1)  # True

head2 = build_list([(1, 1), (2, 1)])
copy2 = copyRandomList(head2)
print("Copy:     ", end=""); print_list(copy2)

head3 = build_list([])
copy3 = copyRandomList(head3)
print("Empty copy:", copy3)  # None

Complexity

• Time: O(n) — two linear passes
• Space: O(n) — hash map stores one entry per node

2. O(1) Space — Interleaving Trick

Intuition

This is a clever technique to avoid the hash map entirely. Instead of a separate map, we interleave copy nodes directly into the original list. Each copy node is inserted right after its original. This lets us find copy_of[node] as node.next — no dictionary needed.

Three phases:

1. Interleave: For each original node, insert copy right after it: A -> A' -> B -> B' -> C -> C'
2. Wire random: node.next.random = node.random.next (copy’s random = copy of original’s random)
3. Separate: Unweave the two lists back apart.

Algorithm

1. Walk the list and insert a copy of each node right after it.
2. Walk again: for each original node cur, if cur.random exists, set cur.next.random = cur.random.next.
3. Walk a third time and separate the interleaved list into original and copy lists.

Solution

class Node:
    def __init__(self, val=0, next=None, random=None):
        self.val = val
        self.next = next
        self.random = random

def build_list(pairs):
    if not pairs:
        return None
    nodes = [Node(val) for val, _ in pairs]
    for i in range(len(nodes) - 1):
        nodes[i].next = nodes[i + 1]
    for i, (_, rand_idx) in enumerate(pairs):
        if rand_idx is not None:
            nodes[i].random = nodes[rand_idx]
    return nodes[0]

def print_list(head):
    node_index = {}
    cur = head
    idx = 0
    while cur:
        node_index[cur] = idx
        cur = cur.next
        idx += 1
    cur = head
    result = []
    while cur:
        rand_idx = node_index[cur.random] if cur.random else None
        result.append(f"[{cur.val}, {rand_idx}]")
        cur = cur.next
    print(" -> ".join(result) if result else "None")

def copyRandomList_o1(head):
    if not head:
        return None

    # Phase 1: interleave copies into original list
    # A -> B -> C  becomes  A -> A' -> B -> B' -> C -> C'
    cur = head
    while cur:
        copy = Node(cur.val)
        copy.next = cur.next
        cur.next = copy
        cur = copy.next  # move to next original node

    # Phase 2: wire random pointers for copies
    cur = head
    while cur:
        if cur.random:
            cur.next.random = cur.random.next  # copy's random = copy of original's random
        cur = cur.next.next  # skip to next original

    # Phase 3: separate the two lists
    copy_head = head.next
    cur = head
    while cur:
        copy = cur.next
        cur.next = copy.next          # restore original list
        copy.next = copy.next.next if copy.next else None  # build copy list
        cur = cur.next

    return copy_head

# Test cases
head1 = build_list([(7, None), (13, 0), (11, 4), (10, 2), (1, 0)])
copy1 = copyRandomList_o1(head1)
print("O(1) Copy: ", end=""); print_list(copy1)
# Verify original is intact
print("Original:  ", end=""); print_list(head1)

head2 = build_list([(1, 1), (2, 1)])
copy2 = copyRandomList_o1(head2)
print("O(1) Copy: ", end=""); print_list(copy2)

Complexity

• Time: O(n) — three linear passes
• Space: O(1) — no extra data structures (beyond the copy nodes themselves)

Common Pitfalls

Pointing random to original nodes instead of copies. The whole point is a deep copy — every pointer in the new list must point to new nodes. Double-check that you’re using old_to_new[node.random] not node.random itself.

Using .get() vs direct key access. When a node’s .next or .random is None, old_to_new[None] will raise a KeyError. Use old_to_new.get(node.next) which safely returns None, or add an explicit if check.

Forgetting to restore the original list in the O(1) approach. The interleaving technique modifies the original list temporarily. The separation step must cleanly restore cur.next = copy.next for all original nodes.

Add Two Numbers

Difficulty: Medium Source: NeetCode

Problem

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list. You may assume the two numbers do not have leading zeros, except the number 0 itself.

Example 1: Input: l1 = [2,4,3], l2 = [5,6,4] Output: [7,0,8] Explanation: 342 + 465 = 807

Example 2: Input: l1 = [0], l2 = [0] Output: [0]

Example 3: Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9] Output: [8,9,9,9,0,0,0,1]

Constraints:

• The number of nodes in each linked list is in the range [1, 100]
• 0 <= Node.val <= 9
• It is guaranteed that the list represents a number that does not have leading zeros

Prerequisites

Before attempting this problem, you should be comfortable with:

• Linked List Traversal — walking two lists simultaneously
• Carry Arithmetic — how digit-by-digit addition with carry works (like doing addition by hand)
• Dummy Head Trick — building a result list cleanly

1. Simulate Addition (Optimal)

Intuition

The lists are already in reverse order — least significant digit first — which is exactly how we do long addition by hand: start from the least significant digit, add, carry the overflow. So we just simulate this process directly on the linked lists.

Walk both lists simultaneously, add corresponding digits plus any carry from the previous step. The sum at each position can be 0–19 (9+9+1 carry), so the digit is total % 10 and the new carry is total // 10. Continue until both lists are exhausted and there’s no remaining carry.

l1 = 2 -> 4 -> 3   (represents 342)
l2 = 5 -> 6 -> 4   (represents 465)

Position 0:  2 + 5 + carry(0) = 7,  digit=7, carry=0
Position 1:  4 + 6 + carry(0) = 10, digit=0, carry=1
Position 2:  3 + 4 + carry(1) = 8,  digit=8, carry=0
Both exhausted, carry=0, done.

Result: 7 -> 0 -> 8  (represents 807)

Algorithm

1. Create a dummy head and a cur pointer.
2. Initialize carry = 0.
3. While l1 or l2 or carry is non-zero:
   • Get digits: v1 = l1.val if l1 else 0, v2 = l2.val if l2 else 0.
   • Compute total = v1 + v2 + carry.
   • New digit: total % 10. New carry: total // 10.
   • Append a new node with the digit to the result.
   • Advance l1 and l2 if they’re not exhausted.
4. Return dummy.next.

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    cur = head
    for v in values[1:]:
        cur.next = ListNode(v)
        cur = cur.next
    return head

def print_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" -> ".join(result) if result else "None")

def addTwoNumbers(l1, l2):
    dummy = ListNode(0)
    cur = dummy
    carry = 0

    while l1 or l2 or carry:
        v1 = l1.val if l1 else 0
        v2 = l2.val if l2 else 0

        total = v1 + v2 + carry
        carry = total // 10
        digit = total % 10

        cur.next = ListNode(digit)
        cur = cur.next

        if l1:
            l1 = l1.next
        if l2:
            l2 = l2.next

    return dummy.next

# Test cases
l1 = build_list([2, 4, 3])  # 342
l2 = build_list([5, 6, 4])  # 465
print("Output: ", end=""); print_list(addTwoNumbers(l1, l2))  # 7->0->8 (807)

l3 = build_list([0])
l4 = build_list([0])
print("Output: ", end=""); print_list(addTwoNumbers(l3, l4))  # 0

l5 = build_list([9, 9, 9, 9, 9, 9, 9])  # 9999999
l6 = build_list([9, 9, 9, 9])            # 9999
print("Output: ", end=""); print_list(addTwoNumbers(l5, l6))  # 8->9->9->9->0->0->0->1

# Lists of different lengths
l7 = build_list([1])
l8 = build_list([9, 9])  # 99 + 1 = 100
print("Output: ", end=""); print_list(addTwoNumbers(l7, l8))  # 0->0->1

# Final carry creates new node
l9 = build_list([5])
l10 = build_list([5])  # 5 + 5 = 10
print("Output: ", end=""); print_list(addTwoNumbers(l9, l10))  # 0->1

Complexity

• Time: O(max(m, n)) — we iterate as many times as the longer list (plus possibly one extra for a final carry)
• Space: O(max(m, n)) — the result list has at most max(m, n) + 1 nodes

2. Convert to Integer and Back (Brute Force)

Intuition

Since the lists are in reverse order, we can read each list as a number, add them as regular Python integers, then convert the result back to a linked list. Python handles arbitrarily large integers, so there’s no overflow concern. This is simple but misses the point of the problem (and wouldn’t work in languages with fixed-size integers).

Algorithm

1. Walk l1 and reconstruct the integer (least significant digit at index 0 means multiply by 10^i).
2. Same for l2.
3. Compute total = num1 + num2.
4. Build the result list from total by repeatedly taking total % 10 and appending.

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    cur = head
    for v in values[1:]:
        cur.next = ListNode(v)
        cur = cur.next
    return head

def print_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" -> ".join(result) if result else "None")

def addTwoNumbers_brute(l1, l2):
    def list_to_int(node):
        num, multiplier = 0, 1
        while node:
            num += node.val * multiplier
            multiplier *= 10
            node = node.next
        return num

    total = list_to_int(l1) + list_to_int(l2)

    if total == 0:
        return ListNode(0)

    dummy = ListNode(0)
    cur = dummy
    while total > 0:
        cur.next = ListNode(total % 10)
        cur = cur.next
        total //= 10
    return dummy.next

# Test
l1 = build_list([2, 4, 3])
l2 = build_list([5, 6, 4])
print("Output: ", end=""); print_list(addTwoNumbers_brute(l1, l2))  # 7->0->8

Complexity

• Time: O(max(m, n)) — similar traversal
• Space: O(max(m, n)) — result list

Common Pitfalls

Forgetting the final carry. After both lists are exhausted, there may still be a carry of 1 (e.g., 5+5=10 leaves carry=1). The while l1 or l2 or carry condition handles this — don’t change it to just while l1 or l2.

Not handling lists of different lengths. If l1 has 3 nodes and l2 has 2, you need to keep going after l2 is exhausted. Use v1 = l1.val if l1 else 0 to safely get 0 when a list runs out.

Advancing both pointers unconditionally. After the loop body, only advance a pointer if it’s not None. if l1: l1 = l1.next — don’t do l1 = l1.next unconditionally or you’ll get an AttributeError.

Reverse Linked List II

Difficulty: Medium Source: NeetCode

Problem

Given the head of a singly linked list and two integers left and right where left <= right, reverse the nodes of the list from position left to position right, and return the reversed list. Positions are 1-indexed.

Example 1: Input: head = [1,2,3,4,5], left = 2, right = 4 Output: [1,4,3,2,5]

Example 2: Input: head = [5], left = 1, right = 1 Output: [5]

Constraints:

• The number of nodes in the list is n
• 1 <= n <= 500
• -500 <= Node.val <= 500
• 1 <= left <= right <= n

Prerequisites

Before attempting this problem, you should be comfortable with:

• Reversing a Linked List — in-place pointer reversal with prev/curr (see problem 1)
• Dummy Head Trick — sentinel node to handle edge cases like reversing from position 1
• Pointer Re-attachment — connecting reversed sublist back to the surrounding nodes

1. Brute Force — Collect and Rebuild

Intuition

Extract the values in the subrange, reverse them, then put them back. Not the most elegant, but easy to reason about and good for verifying the optimal approach.

Algorithm

1. Walk the list and collect all node values into a Python list.
2. Reverse the slice values[left-1:right] in-place.
3. Walk the original list again and overwrite each node’s .val with the new values.

Solution

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def build_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    cur = head
    for v in values[1:]:
        cur.next = ListNode(v)
        cur = cur.next
    return head

def print_list(head):
    result = []
    while head:
        result.append(str(head.val))
        head = head.next
    print(" -> ".join(result) if result else "None")

def reverseBetween_brute(head, left, right):
    values = []
    cur = head
    while cur:
        values.append(cur.val)
        cur = cur.next

    # Reverse the slice [left-1, right) in-place
    l, r = left - 1, right - 1
    while l < r:
        values[l], values[r] = values[r], values[l]
        l += 1
        r -= 1

    # Write values back into nodes
    cur = head
    for v in values:
        cur.val = v
        cur = cur.next

    return head

# Test cases
head = build_list([1, 2, 3, 4, 5])
print("Output: ", end=""); print_list(reverseBetween_brute(head, 2, 4))  # 1->4->3->2->5

head2 = build_list([5])
print("Output: ", end=""); print_list(reverseBetween_brute(head2, 1, 1))  # 5

head3 = build_list([1, 2, 3, 4, 5])
print("Output: ", end=""); print_list(reverseBetween_brute(head3, 1, 5))  # 5->4->3->2->1

Complexity

• Time: O(n) — two passes
• Space: O(n) — storing all values

2. In-Place with Dummy Head (Optimal)

Intuition

We want to reverse exactly the nodes from position left to right without touching anything else. The key is to identify four anchor points:

• prev_left: the node just before position left (we’ll re-attach the reversed segment here)
• The node at position left (it becomes the tail of the reversed segment)
• The node at position right (it becomes the new head of the reversed segment)
• The node just after position right (we’ll re-attach to the tail of the reversed segment)