No history yet

Introduction to Two Pointers

The Two-Pointer Technique

When working with arrays or strings, a common approach is to use a single loop to iterate through the elements one by one. This works, but it's not always the most efficient method. The two-pointer technique is a strategy that uses two indices, or "pointers," to traverse a data structure simultaneously, often from different directions.

By processing two elements per loop, this technique can significantly reduce the time complexity of a solution, often from a quadratic O(n2)O(n^2) down to a linear O(n)O(n).

Imagine you have a sorted array and need to find two numbers that add up to a specific target. A brute-force solution would involve nested loops: one to pick the first number and another to check every other number. This is slow. With the two-pointer approach, you can place one pointer at the beginning of the array and another at the end. By intelligently moving these pointers towards each other based on their sum, you can find the pair in a single pass.

Common Patterns

The two-pointer technique isn't a single algorithm but a family of approaches. Different problems call for different pointer movement strategies. Here are the most common patterns you'll encounter.

The converging pattern is ideal for finding pairs in sorted arrays. The fast and slow pointer approach is frequently used with linked lists to detect cycles or find the middle element. The sliding window pattern is useful for problems involving contiguous subarrays or substrings, like finding the longest substring without repeating characters.

A Basic Implementation

Let's look at the C++ code for the converging pointers pattern. The goal is to find if a pair of numbers in a sorted vector nums sums up to a target.

#include <vector>
#include <iostream>

bool hasPairWithSum(const std::vector<int>& nums, int target) {
    int left = 0; // Pointer starts at the beginning
    int right = nums.size() - 1; // Pointer starts at the end

    while (left < right) {
        int currentSum = nums[left] + nums[right];

        if (currentSum == target) {
            // Found the pair
            return true;
        } else if (currentSum < target) {
            // Sum is too small, need a larger number
            left++;
        } else { // currentSum > target
            // Sum is too large, need a smaller number
            right--;
        }
    }

    // No pair found
    return false;
}

In this example, left and right are our two pointers. The while loop continues as long as the pointers haven't crossed. If the sum of the elements at the pointer locations is too small, we increment the left pointer to include a larger number. If the sum is too large, we decrement the right pointer to include a smaller number. This simple logic allows us to efficiently search the entire array in one pass.

The two-pointer technique is an efficient approach to processing two elements of a data structure, such as an array or list, per loop in order to solve problems involving collections.

This technique is a cornerstone of efficient algorithm design. Recognizing when a problem can be simplified with two pointers is a key skill for tackling many coding challenges.