Course contents
The Two Pointer Technique in Arrays
Two pointers turns a nested loop into a single pass. Instead of trying every pair — O(n2) — you keep two indices and move exactly one of them per step, using a property of the data to decide which. On a sorted array that property is order, and it collapses the problem to O(n).
01Converging pointers
Start one pointer at each end. Compare what they give you against the target, then move the pointer that can possibly improve the situation. Because the array is sorted, moving left right can only increase the sum, and moving right left can only decrease it — so each step eliminates a whole row of the pair matrix.
| Step | left | right | sum | Decision |
|---|---|---|---|---|
| 1 | 0 → 8 | 4 → 99 | 107 | 107 > 80, so the sum must shrink → move right inwards |
| 2 | 0 → 8 | 3 → 63 | 71 | 71 < 80, so the sum must grow → move left inwards |
| 3 | 1 → 17 | 3 → 63 | 80 | Match — return indices (1, 3) |
int[] twoSumSorted(int[] a, int target) {
int left = 0, right = a.length - 1;
while (left < right) {
int sum = a[left] + a[right];
if (sum == target) return new int[]{left, right};
if (sum < target) left++; // need a bigger sum
else right--; // need a smaller sum
}
return new int[]{-1, -1};
}Each iteration moves one pointer inwards and they never cross back, so the loop runs at most n times: O(n) time, O(1) space, against O(n2) for the nested-loop version.
02The fast / slow variant
The second flavour puts both pointers at the start and moves them at different speeds, or moves the trailing one only under a condition. This is the read/write pair from the previous lesson, and it is how in-place filtering works.
int removeDuplicates(int[] a) {
if (a.length == 0) return 0;
int slow = 0; // last unique element
for (int fast = 1; fast < a.length; fast++) {
if (a[fast] != a[slow]) {
a[++slow] = a[fast]; // keep the new value
}
}
return slow + 1; // new length
}03When two pointers applies
- The array is sorted, or sorting it first does not break the question.
- You are looking for a pair or a triple that satisfies a comparison.
- You need to partition or filter in place with O(1) extra space.
- You are working from both ends — palindrome checks, container-with-most-water, reversal.
Key takeaways
- Two pointers replaces a nested loop with one pass when order lets you rule out candidates.
- Converging: one pointer at each end, move the one that can improve the result.
- Fast/slow: both start left, the trailing pointer marks where the next kept element goes.
- O(n) time, O(1) space — and the sort, if you add one, dominates at O(n log n).
Practice problems
Tagged by pattern, so you can tell whether you learned the idea or just the example.
- Two sum on a sorted arrayConverging pointersEasy
- Valid palindrome, ignoring non-alphanumericsConverging pointersEasy
- Container with most waterConverging pointersMedium
- Three sumSort + two pointersMedium
- Trapping rain waterConverging pointersHard
Frequently asked questions
When should I use the two pointer technique?
When the array is sorted (or can be sorted) and you are searching for a pair, a triple, or a partition. The order lets each comparison eliminate many candidates at once instead of one at a time.
Does the array have to be sorted for two pointers?
For the converging variant, effectively yes — the decision about which pointer to move depends on order. The fast/slow variant works on unsorted arrays because it filters rather than compares against a target.
What is the difference between two pointers and sliding window?
A sliding window is a two-pointer variant where the pointers both move forward and the span between them is the answer. Converging two pointers move towards each other and the span shrinks.
Test yourself on Arrays
Reading is not recall. Take a timed quiz on Arrays solo, or share a room code and battle friends on it.