Why Two Pointer Technique Beats Brute Force in DSA Java - Performance Analysis

Time Complexity: Why Two Pointer Technique Beats Brute Force

O(n)

Understanding Time Complexity

We want to see why using two pointers is faster than checking every pair one by one.

How does the number of steps change when input grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public boolean hasPairWithSum(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    while (left < right) {
        int sum = arr[left] + arr[right];
        if (sum == target) return true;
        else if (sum < target) left++;
        else right--;
    }
    return false;
}
    

This code checks if any two numbers in a sorted array add up to a target using two pointers.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The while loop moves pointers through the array.
• How many times: At most, each pointer moves across the array once, so up to n steps total.

How Execution Grows With Input

As the array size grows, the number of steps grows roughly in a straight line.

Input Size (n)	Approx. Operations
10	About 10 steps
100	About 100 steps
1000	About 1000 steps

Pattern observation: Doubling the input roughly doubles the steps needed.

Final Time Complexity

Time Complexity: O(n)

This means the steps grow directly with the size of the input array.

Common Mistake

[X] Wrong: "Two pointers still check every pair, so it's as slow as brute force."

[OK] Correct: Two pointers smartly skip pairs by moving inward, so they never check all pairs, saving many steps.

Interview Connect

Understanding how two pointers reduce repeated work shows your skill in writing efficient code, a key skill in interviews and real projects.

Self-Check

"What if the array was not sorted? How would the time complexity change if we still tried two pointers?"

Practice

1. What is the main advantage of the two pointer technique over brute force in array problems?

easy

A. It uses more memory to store intermediate results

B. It reduces time complexity by avoiding nested loops

C. It always sorts the array first

D. It requires recursion to work

Solution

1. Step 1: Understand brute force approach

   Brute force often uses nested loops, leading to O(n²) time complexity.

2. Step 2: Analyze two pointer technique

   Two pointers move through the array in a single pass, reducing time complexity to O(n).

3. Final Answer:

   It reduces time complexity by avoiding nested loops -> Option B

4. Quick Check:

   Two pointer = faster than brute force [OK]

Hint: Two pointers scan array once, avoiding double loops [OK]

Common Mistakes:

• Thinking two pointer always sorts array
• Assuming it uses more memory
• Believing recursion is required

2. Which of the following is the correct syntax to initialize two pointers in Java for an array arr?

easy

A. int left = arr.length, right = 0;

B. int left = 1, right = arr.length;

C. int left = 0, right = arr.length - 1;

D. int left = -1, right = arr.length + 1;

Solution

1. Step 1: Identify valid pointer positions

   Array indices start at 0 and end at length-1.

2. Step 2: Check initialization correctness

   Left pointer at 0 and right pointer at arr.length - 1 are valid.

3. Final Answer:

   int left = 0, right = arr.length - 1; -> Option C

4. Quick Check:

   Pointers start at array ends [OK]

Hint: Pointers start at 0 and last index (length-1) [OK]

Common Mistakes:

• Starting right pointer at arr.length (out of bounds)
• Starting left pointer at 1 (skips first element)
• Using negative or invalid indices

3. What will be the output of the following Java code snippet?

int[] arr = {1, 2, 3, 4, 5};
int left = 0, right = arr.length - 1;
int sum = 0;
while (left < right) {
  sum += arr[left] + arr[right];
  left++;
  right--;
}
System.out.println(sum);

medium

A. 10

B. 25

C. 15

D. 12

Solution

1. Step 1: Trace pointer movements and sums

   Pairs added: (1+5)=6, (2+4)=6; loop stops when left=right=2.

2. Step 2: Calculate total sum

   Sum = 6 + 6 = 12; loop ends before adding middle element 3.

3. Step 3: Check if middle element added

   Middle element 3 is not added because left == right stops loop.

4. Final Answer:

   12 -> Option D

5. Quick Check:

   Sum pairs from ends = 12 [OK]

Hint: Sum pairs while left < right, middle element excluded [OK]

Common Mistakes:

• Adding middle element when left == right
• Summing all elements instead of pairs
• Miscounting loop iterations

4. Identify the bug in the following two pointer code that tries to find if a pair sums to 10:

int[] arr = {1, 3, 5, 7, 9};
int left = 0, right = arr.length - 1;
boolean found = false;
while (left <= right) {
  int sum = arr[left] + arr[right];
  if (sum == 10) {
    found = true;
    break;
  } else if (sum < 10) {
    left++;
  } else {
    right++;
  }
}
System.out.println(found);

medium

A. Right pointer should decrement, not increment, when sum > 10

B. Left pointer should decrement when sum < 10

C. Loop condition should be left < right, not left <= right

D. Sum calculation is incorrect

Solution

1. Step 1: Understand pointer movement logic

   If sum is less than target, move left pointer right to increase sum; if sum is greater, move right pointer left to decrease sum.

2. Step 2: Identify incorrect pointer update

   Code incorrectly increments right pointer when sum > 10; it should decrement right pointer.

3. Final Answer:

   Right pointer should decrement, not increment, when sum > 10 -> Option A

4. Quick Check:

   Decrease right pointer when sum too big [OK]

Hint: Decrease right pointer if sum too large, increase left if too small [OK]

Common Mistakes:

• Incrementing right pointer instead of decrementing
• Using wrong loop condition
• Miscalculating sum

5. Given a sorted array arr of integers, how can the two pointer technique be used to find all unique pairs that sum to a target value k efficiently?

hard

A. Use two pointers at start and end, move inward adjusting pointers based on sum compared to k

B. Use nested loops to check every pair for sum equal to k

C. Sort the array first, then use binary search for each element to find complement

D. Use recursion to generate all pairs and check sums

Solution

1. Step 1: Initialize two pointers

   Set one pointer at start (left) and one at end (right) of the sorted array.

2. Step 2: Move pointers based on sum comparison

   Calculate sum of elements at pointers; if sum equals k, record pair and move both pointers; if sum less than k, move left pointer right; if sum greater than k, move right pointer left.

3. Step 3: Avoid duplicates by skipping equal elements

   After finding a pair, skip over duplicate elements to ensure unique pairs.

4. Final Answer:

   Use two pointers at start and end, move inward adjusting pointers based on sum compared to k -> Option A

5. Quick Check:

   Two pointer moves inward to find pairs efficiently [OK]

Hint: Move pointers inward based on sum vs target to find pairs fast [OK]

Common Mistakes:

• Using nested loops causing O(n²) time
• Not skipping duplicates leading to repeated pairs
• Using binary search unnecessarily increasing complexity