# Two Pointer Technique

When working with data structures like arrays or linked lists, we often need to compare or correlate the elements within them. Searching for pairs that meet criteria, detecting loops, or reversing order are common tasks. These can be done naively with nested loops, which can be slow and inefficient. This is where the powerful two-pointer technique comes in handy. The two-pointer approach provides an elegant way to traverse and manipulate data structures that improve time complexity. By initializing two pointers at different positions and leveraging their relationship as they move, we can unlock efficient algorithms for complex problems on arrays and linked lists.

## What is the Two-Pointer Approach?

The two-pointer technique uses two-pointers or variables to iterate through a data structure, typically an array or linked list. The key idea is that the pointers start at different positions and move in a coordinated way to traverse the data structure efficiently.

There are two main variants of this technique:

### 1. Converging Pointers:

In this approach, the two pointers start at opposite ends of the data structure and move toward each other. Some examples:

• Finding a pair in a sorted array that sums to a target value. One pointer starts at the beginning, the other at the end. They move toward each other, stopping when they find a pair that matches the target.
• Removing duplicates from a sorted array. One pointer iterates through the array while the other tracks the location to write non-duplicate elements.
• Implementing a sorting algorithm like Quicksort uses pointers from each end to partition the array.

The key benefit is that the entire array can be traversed efficiently in linear time with minimal nested loops.

### 2. Diverging Pointers:

Here, the two pointers start adjacent and iterate through the structure, moving in opposite directions. For example:

• Detecting a loop in a linked list. Two-pointers start at the head and traverse the links. If they ever become equal, there is a loop.
• Finding the midpoint of a linked list in one traversal. A 'slow' pointer moves one node at a time, while the 'fast' pointer moves two nodes at a time. When the fast pointer reaches the end, the slow pointer is at the midpoint.

This technique again provides linear time complexity and reduces unnecessary repeated traversal of elements.

The relationships between the pointers as they move provide the power and efficiency of this technique. By coordinating their movement, intricate manipulations and orderings of data structures can be achieved effectively. Understanding this algorithmic paradigm unlocks solutions for array and linked list problems.

## Uses of Two Pointer Approach

Arrays are one of the most common data structures where two pointers can be leveraged effectively. Some key examples of using two pointers on arrays include:

1. Finding Pairs with Sum in Sorted Array:

Given a sorted array and a target sum, find pairs that equal the target. One pointer starts at the beginning, another at the end. Move the pointers inward, stopping when a pair that sums to the target is found. This takes O(n) time rather than O(n^2) with nested loops.

2. Removing Duplicates from Sorted Array:

Initialize one pointer at the start to traverse the array and another to track the location to write non-duplicates. Compare elements at each traversal pointer. If different, copy the element to the pointer location and increment it. This skips over duplicates in place in O(n) time.

3. Partitioning in Quicksort:

Quicksort uses two pointers to partition the array around a pivot element chosen from the array. One pointer marks the end of the left partition, while the other marks the start of the right partition. Elements are swapped to place them on either side of the pivot properly. The pointers converge to complete the partitioning.

4. Finding Range with Values:

Use two pointers to return a sub-array between given minimum and maximum values. One pointer finds the first element greater than minimum; the other finds the first element greater than maximum. Return the subarray between them containing the range of values.

5. Implementing Sliding Window:

A fixed sliding window of length k can be implemented over an array using two pointers. The right pointer adds new elements to the window; the left pointer removes elements outside the window. Useful for problems like finding max sum subarray of size k.

The two-pointer approach on arrays minimizes repeated linear scans and unnecessary nested loops. By leveraging the relationship between two pointers as they converge or diverge, efficient array algorithms can be designed.

## Advantages of Two Pointer Approach

1. Improved Time Complexity:

The two-pointer technique improves time complexity for many arrays and linked list problems from O(n^2) using nested loops to O(n) for a single linear scan. This efficiency boost allows large datasets to be processed faster.

2. Simpler Logic:

The logic of the two-pointer approach is simpler and more elegant than nesting several loops. Having two variables traverse the data structure lends itself to more readable and maintainable code.

3. Space Efficiency:

Algorithms using the two-pointer technique typically solve problems in place without requiring extra memory allocation. Space complexity is minimized.

4. Easy to Implement:

The two-pointer algorithm only requires initializing two pointers and moving them accordingly based on the problem constraints. This simplicity makes the technique easy to implement.

5. Applicable to Many Problems:

A wide variety of array and linked list problems can be formulated using the two-pointer technique, making it a versatile algorithmic tool. These include search, duplicate removal, partitioning, rotation, etc.

6. Constant Space Usage:

Unlike recursion, the two-pointer technique does not use stack space proportional to the input size. It only requires constant O(1) additional memory regardless of input size.

7. Efficient Handling of Constraints:

Constraints and exceptions involved in array or linked list problems can often be elegantly handled using the relationship and positions of the two pointers during traversal.

The simplicity yet effectiveness of the two-pointer technique makes it a go-to solution for optimizing a wide range of problems dealing with sequential data structures. By mastering this algorithm, many challenges can be solved efficiently.

## Converging Pointers in Detail

Converging pointers use two pointers starting at opposite ends of an array or linked list that move toward each other to solve a problem. Some key aspects of the converging pointers technique:

### Initialization:

The two pointers are initialized at both ends of the data structure. One pointer starts at the first index position 0, while the other starts at the last index n-1 for an array of size n.

For linked lists, one pointer is set to the head node, while the other is set to the last tail node. This setup positions the pointers to traverse the entire structure.

### Traversal:

The two pointers then move toward each other one element at a time. For arrays, this means incrementing one pointer and decrementing the other on each iteration.

For linked lists, one pointer moves to the next node while the other moves to the previous node on each iteration.

### Termination:

The pointers continue traversing until they meet each other or cross paths somewhere in the middle. Certain problems require additional terminating conditions as well.

For example, when finding a pair with a target sum, the pointers stop when a pair that sums to the target is found.

### Applications:

Converging pointers can be used to find something in sorted order, like a pair with a target sum, or to modify the array/list somehow, like removing duplicates or reversing the elements.

The key benefit is eliminating unnecessary traversal and multiple nested loops by coordinating the pointer's movements toward each other from the ends.

By intelligently leveraging the relationship between converging pointers, efficient linear time algorithms can be designed for array and linked list problems. The simplicity of initializing at ends and moving inward makes it versatile.

## Example of Converging Pointers in Python

Let me show you an example program in Python showing the converging pointers technique to find a pair in a sorted array that sums to a target value:

Explanation

1. Define the findPair function, which takes the array and target sum as parameters.
2. Initialize two pointers:
• left pointer at index 0
• right pointer at index len(arr) - 1
This sets them at both ends of the array.
3. Start a while loop that iterates as long as left < right. This ensures pointers have not crossed each other.
4. Calculate the current sum by adding elements at the pointer indices: curr_sum = arr[left] + arr[right]
5. Compare curr_sum to target sum:
• If curr_sum == target, we found a pair. Print the pair and return True.
• Else, if curr_sum < target, move the left pointer one step forward: left += 1
• Else curr_sum > target, move the right pointer one step backward: right -= 1
6. After a while, the loop exits, and no pair is found. Print the message and return False.
7. Call findPair by passing array and target sum. Check if it returns True or False.
8. Print appropriate output messages based on the result.

This demonstrates how the converging pointers can lead to an optimal O(n) solution for problems like finding a pair with a target sum.

## Diverging Pointers in Detail

Diverging pointers refer to initializing two pointers adjacent to each other and then incrementing them in opposite directions through a data structure like an array or linked list.

Initialization:

The two pointers are initialized in adjacent positions, like at the head and head.next to a linked list or index 0 and 1 of an array. This places them together initially to diverge outwards.

Traversal:

The pointers then traverse the data structure in opposite directions. One pointer increments while the other decrements the index/node.

For example, in an array of size n, one pointer may traverse 0 to n-1 while the other goes n-1 to 0.

In a linked list, one pointer goes from head to tail while the other goes from tail to head.

Termination:

The pointers continue diverging until a particular condition is met, like detecting a cycle or finding a midpoint.

To detect a cycle, the pointers traverse until they become equal, indicating a loop in references.

To find the midpoint, a slow pointer moves 1 node at a time while a fast pointer moves 2 nodes. When fast reaches the end, slow is at the midpoint.

Applications:

Diverging pointers can detect cycles, find midpoints, partition data like in Quicksort, reverse linked lists, and more.

The key advantage is eliminating repeated linear scans by traversing once in opposite directions from starting adjacent positions.

In summary, initializing pointers together and divergence in opposite directions enables solving problems like detecting loops efficiently in O(n) time and constant space. The synchronized outward movement is the crux of this technique.

### Python Program

Here is a Python program that demonstrates the diverging pointers technique to detect a cycle in a linked list:

Explanation:

1. Define Node class with value and next reference.
2. Define the has cycle function, which takes the head node as a parameter.
3. Initialize two pointers together:
4. Start loop to traverse list while pointers and fast.next are not null.
5. Increment slow by 1 node, fast by 2 nodes in the loop:
• slow = slow.next
• fast = fast.next.next
6. Check if slow and fast pointers have become equal. If yes, return True as cycle found.
7. After loop, if pointers did not meet, return False as no cycle.
8. Create a sample linked list with a cycle.
9. The call has cycle () on the list head and prints the appropriate message.