Standard array loops are O(n2). These patterns transform slow code into high-speed O(n) systems. This is where you separate the beginners from the experts.

1. Two-Pointer Technique

Used primarily on **sorted arrays**. Instead of nested loops, we use two variables pointing to different elements and move them toward each other.

Efficiency Boost

Reduces nested loops **O(n2)** down to a single pass **O(n)**.

Best For

Finding pairs, reversing arrays, or removing duplicates in-place.

Two-Pointer: Pair Sum

Target Sum: 15

LEFT

RIGHT

Current Sum (1 + 11):12

2. Sliding Window

Imagine a frame (window) that moves over your data. Useful for keeping track of a sub-segment of an array without re-calculating everything inside.

Max Sum SubarrayOptimized O(n)

Sliding Window Logic

Pseudocode

1// Window size k for (int i=0; i < k; i++) sum += arr[i];  for (int i=k; i < n; i++) { sum = sum + arr[i] - arr[i-k]; // Slide! maxSum = max(maxSum, sum); }

Why it works?

When the window moves, you only add one new element and subtract one old one. You DON'T re-sum the middle section.

Substrings
Max Profits
Signal Data
DNA Sequences

Module 2 Complete! ??

You've mastered contiguous memory, fixed vs dynamic sizing, and the heavy-duty algorithms that make arrays powerful. Next up: **Matrices & 2D Data**.

Achievement

Memory Architect

Unlocks

Two-Dimensional Arrays

Basic Operations Next Module: Matrices