3 min read algorithm

Two Pointers Approach in JavaScript

This post explores the two pointers technique in JavaScript, a powerful approach to solving problems related to arrays and strings.

Efficient Problem-Solving with Two Pointers Aproach in JavaScript

The two pointers technique is a crucial method in algorithmic problem-solving, particularly effective with arrays and strings. It involves using two pointer variables, manipulating them to traverse the data structure, often resulting in simplified code and improved performance.

Why Use Two Pointers?

  • Efficiency: It can significantly reduce time complexity, often bringing it down from O(n²) to O(n).
  • Simplicity: This method often simplifies the solution, making the code more readable and maintainable.
  • Versatility: Applicable in various scenarios, such as finding pairs, locating subarrays, or even reversing structures.

Understanding the Basics:

The core idea is to initiate two pointers, usually at the start and end of the array (or string), and then move them based on certain conditions.

  • Opposite Direction Movement: In problems like finding a pair that sums up to a target, the pointers start at opposite ends and move towards each other.
  • Same Direction Movement: For problems like finding the longest substring without repeating characters, both pointers start at one end and move in the same direction.

Example: Finding a Pair with a Given Sum

Problem Statement:

Given an array of integers and a target sum, find a pair of integers in the array whose sum equals the target.

Solution Using Two Pointers:

function findPairWithSum(arr, target) {
  arr.sort((a, b) => a - b);
  let left = 0;
  let right = arr.length - 1;

  while (left < right) {
    const currentSum = arr[left] + arr[right];
    if (currentSum === target) {
      return [arr[left], arr[right]];
    } else if (currentSum < target) {
    } else {

  return null;

How the Code Works:

  • Sorting: The function starts by sorting the array. This step is crucial because it allows the algorithm to effectively utilize the two pointers by knowing which direction to move them based on the sum comparison.
  • Initializing Pointers: Two pointers, left and right, are initialized at the start and end of the array, respectively.
  • Traversing the Array: The loop continues as long as left is less than right. Within the loop, the current sum of the elements pointed by left and right is calculated.
  • Evaluating the Sum: If the current sum is equal to the target, the function returns the pair. If the sum is less than the target, it moves the left pointer to the right (increasing the sum), and if more, it moves the right pointer to the left (decreasing the sum).
  • No Pair Found: If no pair is found that adds up to the target sum, the function returns null.

Read Next

This post explores the implementation of the Binary Search algorithm in JavaScript, demonstrated through a function for calculating successful pairs.
Dive into the effective use of Heaps and Priority Queues in JavaScript to optimize complex algorithmic challenges, illustrated with a practical example.