Two Pointer Technique

Say you have a sorted array. Someone asks you to find two numbers that add up to a target. The simple way is to check every pair. That works but it becomes slow quickly. For a big array it does a huge amount of extra work. The two pointer technique fixes exactly this. It walks through the array once. Then it gives you the answer in a single pass.

🤔 What Is the Two Pointer Technique?

The two pointer technique is a way to solve array problems with two index variables that move through the data instead of one. A pointer here just means an index. It is a position number in the array.

You place two pointers. Then you move them based on what you see. There are two common styles.

• Opposite ends: one pointer starts at the left. The other starts at the right. They move toward each other.
• Slow and fast: both start near the front. One moves faster than the other.

In this tutorial we focus on the opposite-ends style. It is the one used for the classic pair-sum problem.

😣 The Pain: Why Not Just Check Every Pair?

Here is the problem we want to solve. You are given a sorted array and a target number. You need to find a pair of values that add up to that target.

The first idea most people have is to check every possible pair. You pick one number. Then you loop through the rest to see if any of them completes the sum. That is a loop inside a loop.

The trouble is speed. If the array has n items, two nested loops do about n × n checks. That is O(n^2) time. For a small array it feels fine. For an array with a million items it becomes painfully slow.

💡 The Idea: Move Two Pointers From Both Ends

Because the array is sorted, we can be smart. Put one pointer left at the start. Put another pointer right at the end. Now look at the sum of those two values.

Here is the spoken logic.

• If the sum equals the target, we found the pair. Done.
• If the sum is too small, we need a bigger number. So move left one step to the right.
• If the sum is too big, we need a smaller number. So move right one step to the left.

See why this works? The array is sorted. So moving left to the right always gives a larger value. And moving right to the left always gives a smaller value. Each step throws away a number we no longer need. We never go back.

Let us trace it on [1, 3, 5, 7, 11] with a target of 12.

That one matched right away. Let us look at a target where the pointers have to move. Try the same array with target 10.

Notice how few steps that took. We never checked every pair. Each move skipped a whole group of numbers we did not need.

📋 Steps to Find a Pair With Two Pointers

Here is the plan before we write any code.

1. Start left at index 0, the first element.
2. Start right at the last index, the final element.
3. While left is less than right, do the checks below.
4. Find the sum of the values at left and right.
5. If the sum equals the target, return those two positions. You are done.
6. If the sum is less than the target, move left one step to the right.
7. If the sum is greater than the target, move right one step to the left.
8. If left and right meet and you found nothing, there is no such pair.

💻 The Code in 5 Languages

Now let us turn those steps into a function. The function takes a sorted array and a target. It returns the two index positions if a pair is found. If not, it prints a clear message.

#include <stdio.h>

// Find a pair that sums to target in a sorted array.
void findPair(int arr[], int n, int target) {
    int left = 0;          // pointer at the start
    int right = n - 1;     // pointer at the end

    while (left < right) {
        int sum = arr[left] + arr[right];

        if (sum == target) {
            printf("Pair found at index %d and %d\n", left, right);
            return;
        } else if (sum < target) {
            left++;        // sum too small, need a bigger value
        } else {
            right--;       // sum too big, need a smaller value
        }
    }

    printf("No pair found\n");
}

int main() {
    int arr[] = {1, 3, 5, 7, 11};
    int n = 5;
    findPair(arr, n, 10);
    return 0;
}

Pair found at index 1 and 3

#include <iostream>
#include <vector>
using namespace std;

// Find a pair that sums to target in a sorted array.
void findPair(vector<int>& arr, int target) {
    int left = 0;                 // pointer at the start
    int right = arr.size() - 1;   // pointer at the end

    while (left < right) {
        int sum = arr[left] + arr[right];

        if (sum == target) {
            cout << "Pair found at index " << left << " and " << right << endl;
            return;
        } else if (sum < target) {
            left++;               // sum too small, need a bigger value
        } else {
            right--;              // sum too big, need a smaller value
        }
    }

    cout << "No pair found" << endl;
}

int main() {
    vector<int> arr = {1, 3, 5, 7, 11};
    findPair(arr, 10);
    return 0;
}

Pair found at index 1 and 3

public class TwoPointer {

    // Find a pair that sums to target in a sorted array.
    static void findPair(int[] arr, int target) {
        int left = 0;                  // pointer at the start
        int right = arr.length - 1;    // pointer at the end

        while (left < right) {
            int sum = arr[left] + arr[right];

            if (sum == target) {
                System.out.println("Pair found at index " + left + " and " + right);
                return;
            } else if (sum < target) {
                left++;                // sum too small, need a bigger value
            } else {
                right--;               // sum too big, need a smaller value
            }
        }

        System.out.println("No pair found");
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 11};
        findPair(arr, 10);
    }
}

Pair found at index 1 and 3

# Find a pair that sums to target in a sorted array.
def find_pair(arr, target):
    left = 0                # pointer at the start
    right = len(arr) - 1    # pointer at the end

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

        if total == target:
            print(f"Pair found at index {left} and {right}")
            return
        elif total < target:
            left += 1       # sum too small, need a bigger value
        else:
            right -= 1      # sum too big, need a smaller value

    print("No pair found")


arr = [1, 3, 5, 7, 11]
find_pair(arr, 10)

Pair found at index 1 and 3

// Find a pair that sums to target in a sorted array.
function findPair(arr, target) {
  let left = 0;                 // pointer at the start
  let right = arr.length - 1;   // pointer at the end

  while (left < right) {
    const sum = arr[left] + arr[right];

    if (sum === target) {
      console.log(`Pair found at index ${left} and ${right}`);
      return;
    } else if (sum < target) {
      left++;                   // sum too small, need a bigger value
    } else {
      right--;                  // sum too big, need a smaller value
    }
  }

  console.log("No pair found");
}

const arr = [1, 3, 5, 7, 11];
findPair(arr, 10);

Pair found at index 1 and 3

The values at index 1 and 3 are 3 and 7. They add up to 10. That is our target.

⏱️ Complexity Compared

Here is how the two pointer method stacks up against the simple nested-loop idea.

⚠️ Common Mistakes to Avoid

A few small slips trip people up with this technique.

• Using it on an unsorted array. The whole logic depends on order. On an unsorted array the moves make no sense. Sort it first.
• Writing the loop as left <= right. With <= you can pair an element with itself, which is usually wrong. Use left < right.
• Moving the wrong pointer. When the sum is too small you move left, not right. Mixing these up sends the pointers the wrong way. Then you miss the pair.
• Forgetting the no-pair case. If the loop ends without a match, return a clear “not found” result instead of leaving the answer empty.

🧩 What You’ve Learned

✅ The two pointer technique uses two moving indices instead of one to scan an array.

✅ For a pair-sum problem on a sorted array, start one pointer at each end and move them toward each other.

✅ Move left right when the sum is too small, and move right left when the sum is too big.

✅ This turns a slow O(n^2) nested loop into a fast O(n) single pass with O(1) extra space.

✅ The array must be sorted for the opposite-ends version to work.

🚀 What’s Next?

• Sliding Window Technique
• Reverse an Array