Using the Two Pointer Technique

---

The two pointer technique is a near necessity in any software developer's toolkit, especially when it comes to technical interviews. In this guide, we'll cover the basics so that you know when and how to use this technique.

What is the pattern?

Using two pointers is exactly as it sounds: it's the use of two different pointers (usually in order to keep track of array or string indices) to solve a problem involving said indices.

When do we use it?

The pattern can be used for string or array questions that can be streamlined and made more efficient by iterating through two parts of an object simultaneously, like in the Two Sum problem or Reverse a String.

Running through an example

One usage is while searching for pairs in an array. Let us consider a practical example: assume that you have a sorted array arr.

You're tasked with figuring out the pair of elements where arr[p] + arr[q] add up to a certain number. (To try this problem out, check the Two Sum and Sorted Two Sum problems here.)

The brute force solution is to compare each element with every other number, but that's a time complexity of O(n^2). We can do better!

So let's optimize. You need to identify the indices pointer_one and pointer_two whose values sum to integer target.

Let's initialize two variables, pointer_one and pointer_two, and consider them as our two pointers.

pointer_one = 0
pointer_two = len(arr)-1

Note that len(arr)-1 helps to get the last index possible in an array.

Also observe that when we start, pointer_one points to the first element of the array, and pointer_two points to the last element.

This won't always be the case with this technique (we'll explore the sliding window concept later, which uses two pointers but have them move in a different direction). For our current purposes, it is more efficient to start wide, and iteratively narrow in (particularly if the array is sorted).

def two_sum(arr, target):
    pointer_one = 0
    pointer_two = input.length - 1

    while pointer_one < pointer_two:

Since the array is already sorted, and we're looking to process an index at each iteration, we can use two pointers to process them faster. One pointer starts from the beginning of the array, and the other pointer begins from the end of the array, and then we add the values at these pointers.

Once we're set up, what we want to do is check if the current pointers already sum up to our target. This might happen if the correct ones are on the exact opposite ends of the array.

Here's what the check might look like:

if sum == targetValue:
  return true

However, it likely will not be the target immediately. Thus, we apply this logic: if the sum of the values is less than the target value, we increment the left pointer (move your left pointer pointer_one one index rightwards).

And if the sum is higher than the target value, we decrement the right pointer (correct the position of your pointer pointer_two if necessary).

elif sum < targetValue:
  pointer_one += 1
else:
  pointer_two -= 1

In other words, understand that if arr[pointer_one] < target-arr[pointer_two], it means we should move forward on pointer_one to get closer to where we want to be in magnitude.

This is what it looks like all put together:

def two_sum(arr, target):
    pointer_one = 0
    pointer_two = input.length - 1

    while pointer_one < pointer_two:
        sum = input[pointer_one] + input[pointer_two]

        if sum == targetValue:
            return true
        elif sum < targetValue:
            pointer_one += 1
        else:
            pointer_two -= 1

    return false

It's crucial to see that how both indices were moving in conjunction, and how they depend on each other.

We kept moving the pointers until we got the sum that matches the target value-- or until we reached the middle of the array, and no combinations were found.

The time complexity of this solution is O(n) and space complexity is O(1), a significant improvement over our first implementation!

---

---

Back