Two Pointer Technique on Arrays in DSA C# - Execution Trace

Concept Flow - Two Pointer Technique on Arrays

Initialize left pointer at start

↓

Initialize right pointer at end

↓

Check condition: left < right?

No→Stop

Yes↓

Process elements at left and right

↓

Move pointers inward (left++, right--)

↩Back to condition check

Start with two pointers at both ends of the array, move them towards each other while processing elements until they meet or cross.

Execution Sample

DSA C#

int left = 0;
int right = arr.Length - 1;
while (left < right) {
  // process arr[left] and arr[right]
  left++;
  right--;
}

This code uses two pointers moving inward from both ends of the array, processing pairs of elements.

Execution Table

Step	Operation	Left Pointer	Right Pointer	Array State	Action
1	Initialize pointers	0	5	[2, 4, 7, 8, 9, 10]	Start with left=0, right=5
2	Check condition	0	5	[2, 4, 7, 8, 9, 10]	0 < 5 is True, continue
3	Process elements	0	5	[2, 4, 7, 8, 9, 10]	Process arr[0]=2 and arr[5]=10
4	Move pointers	1	4	[2, 4, 7, 8, 9, 10]	left++=1, right--=4
5	Check condition	1	4	[2, 4, 7, 8, 9, 10]	1 < 4 is True, continue
6	Process elements	1	4	[2, 4, 7, 8, 9, 10]	Process arr[1]=4 and arr[4]=9
7	Move pointers	2	3	[2, 4, 7, 8, 9, 10]	left++=2, right--=3
8	Check condition	2	3	[2, 4, 7, 8, 9, 10]	2 < 3 is True, continue
9	Process elements	2	3	[2, 4, 7, 8, 9, 10]	Process arr[2]=7 and arr[3]=8
10	Move pointers	3	2	[2, 4, 7, 8, 9, 10]	left++=3, right--=2
11	Check condition	3	2	[2, 4, 7, 8, 9, 10]	3 < 2 is False, stop

💡 Pointers crossed (left=3, right=2), condition left < right is False, loop ends

Variable Tracker

Variable	Start	After Step 4	After Step 7	After Step 10	Final
left	0	1	2	3	3
right	5	4	3	2	2

Key Moments - 3 Insights

Why does the loop stop when left pointer is not less than right pointer?

Because the two pointers have met or crossed, meaning all pairs have been processed. See execution_table step 11 where left=3 and right=2, condition left < right is False.

What happens if the array has an odd number of elements?

The pointers will meet at the middle element, which can be processed alone or skipped depending on the problem. The loop stops when left >= right as shown in execution_table steps.

Why do we move left pointer forward and right pointer backward each iteration?

To process pairs from both ends moving inward, ensuring no element is missed or processed twice. This is shown in execution_table steps 4, 7, and 10 where pointers move closer.

Visual Quiz - 3 Questions

Look at the execution_table, what are the values of left and right pointers at step 7?

A left=3, right=2

B left=1, right=4

C left=2, right=3

D left=0, right=5

💡 Hint

Check the 'Left Pointer' and 'Right Pointer' columns in execution_table row 7

At which step does the condition left < right become false?

A Step 9

B Step 11

C Step 10

D Step 8

💡 Hint

Look at the 'Operation' and 'Action' columns in execution_table step 11

If we start with left=1 and right=4 instead of 0 and 5, how would the first check condition change?

A It would check if 1 < 4

B It would check if 0 < 5

C It would check if 1 > 4

D It would check if 4 < 1

💡 Hint

Refer to execution_table step 2 where condition is left < right

Concept Snapshot

Two Pointer Technique on Arrays:
- Use two pointers starting at opposite ends
- Move pointers inward while condition left < right holds
- Process elements at both pointers each step
- Stops when pointers meet or cross
- Useful for pairwise processing or searching in sorted arrays

Full Transcript

The Two Pointer Technique on Arrays uses two pointers starting at the beginning and end of the array. They move towards each other, processing elements at each pointer. The loop continues while the left pointer is less than the right pointer. When they meet or cross, the process stops. This technique helps efficiently process pairs or search in sorted arrays by reducing the number of iterations needed.

Practice

1. What is the main idea behind the Two Pointer Technique when used on arrays?

easy

A. Use two indices to traverse the array from different ends or positions simultaneously

B. Use one pointer to traverse and another to store values

C. Sort the array first and then use binary search

D. Use recursion to split the array into two parts

Solution

1. Step 1: Understand the two pointer approach

   The technique uses two pointers (indices) to scan the array from different positions, often from start and end. This helps solve problems efficiently by reducing the number of iterations compared to nested loops.

2. Final Answer:

   Use two indices to traverse the array from different ends or positions simultaneously -> Option A

3. Quick Check:

   Two pointers move from different ends = D [OK]

Hint: Two pointers move from start and end to meet in middle [OK]

Common Mistakes:

• Thinking it always requires sorting first
• Using only one pointer instead of two
• Confusing with recursion or binary search

2. Which of the following is the correct syntax to initialize two pointers left and right for an array arr in C#?

easy

A. int left = -1, right = arr.Length + 1;

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

C. int left = arr.Length, right = 0;

D. int left = 0, right = arr.Length - 1;

Solution

1. Step 1: Understand array indexing and initialize pointers correctly

   Arrays start at index 0 and end at index Length - 1. Left pointer starts at 0 (first element), right pointer at Length - 1 (last element).

2. Final Answer:

   int left = 0, right = arr.Length - 1; -> Option D

3. Quick Check:

   Start at 0 and end at Length-1 = A [OK]

Hint: Start left at 0, right at length minus one [OK]

Common Mistakes:

• Starting right pointer at arr.Length (out of bounds)
• Starting left pointer at 1 instead of 0
• Using negative indices

3. What will be the output of the following C# code?

int[] arr = {1, 2, 3, 4, 5, 6};
int left = 0, right = arr.Length - 1;
int sum = 0;
while (left < right) {
    sum += arr[left] + arr[right];
    left++;
    right--;
}
Console.WriteLine(sum);

medium

A. 21

B. 18

C. 20

D. 15

Solution

1. Step 1: Trace the loop iterations

   Pairs added: (1+6)=7, (2+5)=7, (3+4)=7; sum = 7+7+7 = 21. Loop runs while left < right, so stops after these pairs.

2. Final Answer:

   21 -> Option A

3. Quick Check:

   Sum of pairs from ends = 21 [OK]

Hint: Sum pairs from ends until pointers meet [OK]

Common Mistakes:

• Adding elements twice
• Loop running when left equals right
• Incorrect sum calculation

4. Identify the error in the following C# code using two pointers to find if array arr contains two numbers that sum to 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;

medium

A. The sum calculation is incorrect

B. The pointers should both start at 0

C. The loop condition should be left < right instead of left <= right

D. The return statements are missing a value

Solution

1. Step 1: Analyze loop condition

   Using left <= right allows pointers to be equal, causing sum of same element twice. Change to left < right to avoid using the same element twice.

2. Final Answer:

   The loop condition should be left < right instead of left <= right -> Option C

3. Quick Check:

   Pointers must not cross or equal for two distinct elements [OK]

Hint: Use left < right to avoid same element twice [OK]

Common Mistakes:

• Allowing pointers to be equal causing wrong sums
• Starting both pointers at 0
• Misplacing return statements

5. Given a sorted array arr and a number k, how can you use the two pointer technique to find if there exists a pair with sum equal to k? Choose the correct approach.

hard

A. Initialize both pointers at start; move both right until sum equals k

B. Initialize two pointers at start and end; move left pointer right if sum < k, else move right pointer left

C. Initialize two pointers at middle; move both outward until sum equals k

D. Sort the array again and use binary search for each element

Solution

1. Step 1: Set pointers and move based on sum

   Left pointer at 0, right pointer at last index. If sum < k, move left right to increase sum; if sum > k, move right left to decrease sum.

2. Final Answer:

   Initialize two pointers at start and end; move left pointer right if sum < k, else move right pointer left -> Option B

3. Quick Check:

   Two pointers adjust to reach target sum efficiently [OK]

Hint: Move pointers inward based on sum comparison [OK]

Common Mistakes:

• Starting both pointers at same side
• Moving pointers in wrong direction
• Sorting array again unnecessarily