LeetCode Pattern/Two Pointers/Opposite Direction Two Pointers: Template, Examples, and When to Use It

Opposite Direction Two Pointers: Template, Examples, and When to Use It

LeetCopilot Team

Dec 9, 2025

15 min read

Two PointersOpposite DirectionSorted ArraysTemplatesInterview Prep

Master the converging pointers pattern with production-ready templates in Python, JavaScript, and Java. Learn when to use opposite direction two pointers, common patterns, and how to avoid mistakes.

Complete Guide

The Complete Two Pointers Guide: Master All Patterns, Templates, and Techniques

The ultimate comprehensive guide to two pointers. Learn all variants, when to use each pattern, complete templates in multiple languages, and a systematic approach to solve any two pointers problem.

Read the complete guide

The opposite direction two pointers pattern—where pointers start at both ends and converge toward the middle—is one of the most elegant algorithmic techniques you'll encounter.

It transforms O(n²) brute force solutions into O(n) optimal solutions. It's used in dozens of LeetCode problems. And once you understand the template, you can solve an entire class of problems in minutes.

But here's the challenge: knowing when to use it and implementing it correctly requires understanding the underlying principles, not just memorizing code.

This comprehensive guide will teach you the complete opposite direction template, when to apply it, common patterns, and how to avoid the mistakes that trip up most developers.

TL;DR

Use opposite direction two pointers when:

Array is sorted (or you can sort it)
Looking for pairs that meet a condition
Checking symmetry (palindromes)
Making greedy decisions based on pointer values

Template:

python

left, right = 0, len(arr) - 1
while left < right:
    if condition_met(arr[left], arr[right]):
        return result
    elif need_larger_value:
        left += 1
    else:
        right -= 1

Time: O(n), Space: O(1)

What Is Opposite Direction Two Pointers?

The Core Concept

Two pointers start at opposite ends of an array and move toward each other, making decisions based on the values they point to.

Visual:

code

[1, 2, 3, 4, 5, 6, 7, 8, 9]
 L                       R

[1, 2, 3, 4, 5, 6, 7, 8, 9]
    L                 R

[1, 2, 3, 4, 5, 6, 7, 8, 9]
       L           R

... continue until L >= R

Why It Works

The key insight: on a sorted array, you can make greedy decisions about which pointer to move based on the current values.

Example: Finding two numbers that sum to a target.

If arr[left] + arr[right] < target, we need a larger sum → move left right
If arr[left] + arr[right] > target, we need a smaller sum → move right left
If equal, we found the answer

This works because the array is sorted, giving us the monotonicity needed for greedy decisions.

The Universal Template

Python Template

python

def opposite_direction_template(arr, target):
    """
    Template for opposite direction two pointers.
    
    Args:
        arr: Sorted array
        target: Target value or condition
    
    Returns:
        Result based on problem requirements
    """
    # Edge case: array too small
    if len(arr) < 2:
        return None  # or appropriate default
    
    # Initialize pointers at opposite ends
    left = 0
    right = len(arr) - 1
    
    # Converge toward middle
    while left < right:
        # Calculate current state
        current = compute(arr[left], arr[right])
        
        # Check if condition is met
        if current == target:
            return [left, right]  # or appropriate result
        
        # Make greedy decision
        elif current < target:
            # Need larger value, move left pointer right
            left += 1
        else:
            # Need smaller value, move right pointer left
            right -= 1
    
    # No solution found
    return None

JavaScript Template

javascript

function oppositeDirectionTemplate(arr, target) {
    if (arr.length < 2) return null;
    
    let left = 0;
    let right = arr.length - 1;
    
    while (left < right) {
        const current = compute(arr[left], arr[right]);
        
        if (current === target) {
            return [left, right];
        } else if (current < target) {
            left++;
        } else {
            right--;
        }
    }
    
    return null;
}

Java Template

java

public int[] oppositeDirectionTemplate(int[] arr, int target) {
    if (arr.length < 2) return new int[]{};
    
    int left = 0;
    int right = arr.length - 1;
    
    while (left < right) {
        int current = compute(arr[left], arr[right]);
        
        if (current == target) {
            return new int[]{left, right};
        } else if (current < target) {
            left++;
        } else {
            right--;
        }
    }
    
    return new int[]{};
}

Pattern 1: Two Sum (Sorted Array)

Problem

Given a sorted array, find two numbers that sum to a target value.

Solution

python

def twoSum(numbers: List[int], target: int) -> List[int]:
    """
    LeetCode #167: Two Sum II - Input Array Is Sorted
    
    Time: O(n)
    Space: O(1)
    """
    left, right = 0, len(numbers) - 1
    
    while left < right:
        current_sum = numbers[left] + numbers[right]
        
        if current_sum == target:
            return [left + 1, right + 1]  # 1-indexed
        elif current_sum < target:
            left += 1  # Need larger sum
        else:
            right -= 1  # Need smaller sum
    
    return []  # No solution (shouldn't happen per problem constraints)

Why It Works

Sorted array property:

numbers[left] is the smallest unconsidered value
numbers[right] is the largest unconsidered value

Greedy decision:

Sum too small? Increase it by moving left right
Sum too large? Decrease it by moving right left

Proof of correctness: See unsorted array mistake for why this only works on sorted arrays.

Example Trace

code

Input: numbers = [2, 7, 11, 15], target = 9

Step 1: left=0, right=3
  numbers[0]=2, numbers[3]=15
  sum = 17 > 9 → right--

Step 2: left=0, right=2
  numbers[0]=2, numbers[2]=11
  sum = 13 > 9 → right--

Step 3: left=0, right=1
  numbers[0]=2, numbers[1]=7
  sum = 9 == 9 → Found! Return [1, 2]

Pattern 2: Valid Palindrome

Problem

Check if a string is a palindrome, ignoring non-alphanumeric characters and case.

Solution

python

def isPalindrome(s: str) -> bool:
    """
    LeetCode #125: Valid Palindrome
    
    Time: O(n)
    Space: O(1) if we skip on-the-fly, O(n) if we clean first
    """
    # Clean the string
    cleaned = ''.join(c.lower() for c in s if c.isalnum())
    
    # Check palindrome with opposite direction pointers
    left, right = 0, len(cleaned) - 1
    
    while left < right:
        if cleaned[left] != cleaned[right]:
            return False
        left += 1
        right -= 1
    
    return True

Why It Works

Symmetry property: A palindrome reads the same forward and backward.

Greedy decision: Compare characters from both ends. If any pair doesn't match, it's not a palindrome.

Optimization: We can stop at the middle because we've checked all pairs.

Alternative: Skip Non-Alphanumeric On-the-Fly

python

def isPalindrome(s: str) -> bool:
    """
    O(1) space version - skip non-alphanumeric without creating new string
    """
    left, right = 0, len(s) - 1
    
    while left < right:
        # Skip non-alphanumeric from left
        while left < right and not s[left].isalnum():
            left += 1
        
        # Skip non-alphanumeric from right
        while left < right and not s[right].isalnum():
            right -= 1
        
        # Compare (case-insensitive)
        if s[left].lower() != s[right].lower():
            return False
        
        left += 1
        right -= 1
    
    return True

Pattern 3: Container With Most Water

Problem

Given heights of vertical lines, find two lines that form a container with maximum water.

Solution

python

def maxArea(height: List[int]) -> int:
    """
    LeetCode #11: Container With Most Water
    
    Time: O(n)
    Space: O(1)
    """
    left, right = 0, len(height) - 1
    max_area = 0
    
    while left < right:
        # Calculate current area
        width = right - left
        current_height = min(height[left], height[right])
        area = width * current_height
        
        # Update maximum
        max_area = max(max_area, area)
        
        # Greedy decision: move the shorter line
        if height[left] < height[right]:
            left += 1
        else:
            right -= 1
    
    return max_area

Why It Works

Key insight: Area is limited by the shorter line.

Greedy decision: Moving the taller line can never increase area (width decreases, height stays limited). Moving the shorter line is the only hope.

Proof: See Container With Most Water proof.

Pattern 4: Trapping Rain Water

Problem

Calculate how much water can be trapped between bars.

Solution

python

def trap(height: List[int]) -> int:
    """
    LeetCode #42: Trapping Rain Water
    
    Time: O(n)
    Space: O(1)
    """
    if not height:
        return 0
    
    left, right = 0, len(height) - 1
    left_max, right_max = height[left], height[right]
    water = 0
    
    while left < right:
        if height[left] < height[right]:
            # Process left side
            if height[left] >= left_max:
                left_max = height[left]
            else:
                water += left_max - height[left]
            left += 1
        else:
            # Process right side
            if height[right] >= right_max:
                right_max = height[right]
            else:
                water += right_max - height[right]
            right -= 1
    
    return water

Why It Works

Key insight: Water at position i is determined by min(max_left, max_right) - height[i].

Greedy decision: Process the side with the smaller max, because it's the limiting factor.

When to Use Opposite Direction

✅ Use When:

Array is sorted (or you can sort it without losing required information)
Looking for pairs that meet a condition
Checking symmetry (palindromes, mirroring)
Greedy decisions can be made based on pointer values
Want O(1) space (vs hash map's O(n))

❌ Don't Use When:

Array is unsorted and you need original indices
Looking for triplets/quadruplets (use nested loops + two pointers)
Need to track all elements between pointers (use sliding window)
Can't make greedy decisions (need exhaustive search)

Common Mistakes

Mistake 1: Wrong Loop Condition

python

# WRONG: Uses <=
while left <= right:
    # Processes middle element twice!

Fix: Use left < right for pairs.

Mistake 2: Incorrect Pointer Initialization

python

# WRONG: right out of bounds
right = len(arr)  # Should be len(arr) - 1

Fix: right = len(arr) - 1

Mistake 3: Not Handling Edge Cases

python

# WRONG: Doesn't check array size
left, right = 0, len(arr) - 1
# Crashes if arr is empty!

Fix: Check if len(arr) < 2: return default

Mistake 4: Using on Unsorted Arrays

python

# WRONG: Array is unsorted
arr = [3, 2, 4]
# Two pointers won't work correctly!

Fix: Sort first or use hash map. See unsorted array mistake.

Advanced Techniques

Technique 1: Extending to 3Sum

python

def threeSum(nums: List[int]) -> List[List[int]]:
    """
    Fix one element, use two pointers on the rest
    """
    nums.sort()
    result = []
    
    for i in range(len(nums) - 2):
        # Skip duplicates for i
        if i > 0 and nums[i] == nums[i-1]:
            continue
        
        # Two pointers on remaining array
        left, right = i + 1, len(nums) - 1
        target = -nums[i]
        
        while left < right:
            current_sum = nums[left] + nums[right]
            
            if current_sum == target:
                result.append([nums[i], nums[left], nums[right]])
                
                # Skip duplicates
                while left < right and nums[left] == nums[left+1]:
                    left += 1
                while left < right and nums[right] == nums[right-1]:
                    right -= 1
                
                left += 1
                right -= 1
            elif current_sum < target:
                left += 1
            else:
                right -= 1
    
    return result

Technique 2: Tracking Multiple Conditions

python

def threeSumClosest(nums: List[int], target: int) -> int:
    """
    Track closest sum while using two pointers
    """
    nums.sort()
    closest = float('inf')
    
    for i in range(len(nums) - 2):
        left, right = i + 1, len(nums) - 1
        
        while left < right:
            current_sum = nums[i] + nums[left] + nums[right]
            
            # Update closest
            if abs(current_sum - target) < abs(closest - target):
                closest = current_sum
            
            # Move pointers
            if current_sum < target:
                left += 1
            elif current_sum > target:
                right -= 1
            else:
                return current_sum  # Exact match
    
    return closest

Practice Problems

Master opposite direction with these problems:

Beginner:

Two Sum II (#167) - basic template
Valid Palindrome (#125) - symmetry check
Reverse String (#344) - simple swapping

Intermediate:
4. 3Sum (#15) - extend to triplets
5. Container With Most Water (#11) - greedy choice
6. 3Sum Closest (#16) - tracking closest

Advanced:
7. Trapping Rain Water (#42) - complex greedy
8. 4Sum (#18) - nested two pointers
9. Valid Palindrome II (#680) - allow one deletion

Complexity Analysis

Time Complexity: O(n)

Each pointer moves at most n positions
Each element visited at most twice
Total: O(2n) = O(n)

Space Complexity: O(1)

Only use two pointer variables
No additional data structures

Comparison with brute force:

Brute force: O(n²) - check all pairs
Two pointers: O(n) - check each element once

FAQ

Q: Why does this only work on sorted arrays?

A: Sorting gives us monotonicity, allowing greedy decisions. On unsorted arrays, we can't determine which pointer to move. See unsorted array mistake.

Q: Can I use this for triplets or quadruplets?

A: Yes! Fix one (or two) elements, then use two pointers on the rest. See advanced multi-pointer.

Q: What if I need original indices?

A: If sorting loses required indices, use a hash map instead. See hash map vs two pointers.

Q: How do I avoid off-by-one errors?

A: Use left < right (not <=), initialize right = len(arr) - 1, and calculate window size as right - left + 1. See off-by-one errors.

Conclusion

The opposite direction two pointers pattern is a powerful technique that transforms quadratic solutions into linear ones.

Key principles:

Sorted array enables greedy decisions
Converge from both ends toward the middle
Make decisions based on pointer values
O(n) time, O(1) space - optimal efficiency

The template:

python

left, right = 0, len(arr) - 1
while left < right:
    if condition_met:
        return result
    elif need_larger:
        left += 1
    else:
        right -= 1

When to use:

Sorted arrays + pairs
Palindrome checking
Greedy optimization (container, water)

Master this template, and you'll solve dozens of LeetCode problems with confidence. For more patterns, see the complete two pointers guide and fast/slow pointers.

Next time you see a sorted array and need to find pairs, reach for opposite direction two pointers.

Want to Practice LeetCode Smarter?

LeetCopilot is a free browser extension that enhances your LeetCode practice with AI-powered hints, personalized study notes, and realistic mock interviews — all designed to accelerate your coding interview preparation.

Learn More About LeetCopilot

Add to Chrome for free

Also compatible with Edge, Brave, and Opera

Opposite Direction Two Pointers: Template, Examples, and When to Use It

The Complete Two Pointers Guide: Master All Patterns, Templates, and Techniques

TL;DR

What Is Opposite Direction Two Pointers?

The Core Concept

Why It Works

The Universal Template

Python Template

JavaScript Template

Java Template

Pattern 1: Two Sum (Sorted Array)

Problem

Solution

Why It Works

Example Trace

Pattern 2: Valid Palindrome

Problem

Solution

Why It Works

Alternative: Skip Non-Alphanumeric On-the-Fly

Pattern 3: Container With Most Water

Problem

Solution

Why It Works

Pattern 4: Trapping Rain Water

Problem

Solution

Why It Works

When to Use Opposite Direction

✅ Use When:

❌ Don't Use When:

Common Mistakes

Mistake 1: Wrong Loop Condition

Mistake 2: Incorrect Pointer Initialization

Mistake 3: Not Handling Edge Cases

Mistake 4: Using on Unsorted Arrays

Advanced Techniques

Technique 1: Extending to 3Sum

Technique 2: Tracking Multiple Conditions

Practice Problems

Complexity Analysis

FAQ

Conclusion

Want to Practice LeetCode Smarter?

Related Tutorials

Why Your Two Pointers Solution Fails on Unsorted Arrays (And What to Use Instead)

The Off-by-One Trap in Two Pointers: How to Get Pointer Bounds Right Every Time

How to Debug Two Pointers Solutions: Visualization and Common Patterns