Remove Duplicates from Sorted Array Two Pointer in DSA C - Execution Trace

Concept Flow - Remove Duplicates from Sorted Array Two Pointer

Start with two pointers

↓

Pointer1 at index 0

↓

Compare elements at Pointer1 and Pointer2

↓

Repeat until Pointer2 reaches end

↓

Return length = Pointer1 + 1

Use two pointers to scan the array. One tracks unique elements, the other scans ahead to find new unique values.

Execution Sample

DSA C

int removeDuplicates(int* nums, int numsSize) {
    int i = 0;
    for (int j = 1; j < numsSize; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}

This code removes duplicates in-place from a sorted array using two pointers and returns the new length.

Execution Table

Step	Operation	Pointer i (unique index)	Pointer j (scan index)	Array State	Action
0	Initialize pointers	0	1	[1,1,2,2,3]	Start with i=0, j=1
1	Compare nums[j] and nums[i]	0	1	[1,1,2,2,3]	nums[1]=1 == nums[0]=1, duplicate found, move j
2	Increment j	0	2	[1,1,2,2,3]	j moves to 2
3	Compare nums[j] and nums[i]	0	2	[1,1,2,2,3]	nums[2]=2 != nums[0]=1, unique found
4	Increment i and copy nums[j]	1	2	[1,2,2,2,3]	i=1, nums[1]=2
5	Increment j	1	3	[1,2,2,2,3]	j moves to 3
6	Compare nums[j] and nums[i]	1	3	[1,2,2,2,3]	nums[3]=2 == nums[1]=2, duplicate found, move j
7	Increment j	1	4	[1,2,2,2,3]	j moves to 4
8	Compare nums[j] and nums[i]	1	4	[1,2,2,2,3]	nums[4]=3 != nums[1]=2, unique found
9	Increment i and copy nums[j]	2	4	[1,2,3,2,3]	i=2, nums[2]=3
10	Increment j	2	5	[1,2,3,2,3]	j moves beyond array length, stop
11	Return new length	2	5	[1,2,3,2,3]	Length = i + 1 = 3

💡 j reaches 5 which is numsSize, loop ends

Variable Tracker

Variable	Start	After Step 4	After Step 9	Final
i	0	1	2	2
j	1	2	4	5
nums	[1,1,2,2,3]	[1,2,2,2,3]	[1,2,3,2,3]	[1,2,3,2,3]

Key Moments - 3 Insights

Why do we increment pointer i only when we find a new unique element?

Because i tracks the position of the last unique element. We only move it forward to store the next unique value, as shown in steps 4 and 9.

Why do we compare nums[j] with nums[i] and not nums[j-1]?

Pointer i always points to the last unique element, so comparing nums[j] with nums[i] ensures we detect duplicates correctly, as seen in steps 3 and 8.

What happens to the elements after the new length?

They remain unchanged but are ignored. The function returns the new length (i+1), so only the first part of the array up to that length is valid, as in step 11.

Visual Quiz - 3 Questions

Look at the execution table at step 4, what is the value of pointer i?

A 1

B 0

C 2

D 3

💡 Hint

Check the 'Pointer i (unique index)' column at step 4 in the execution table.

At which step does the pointer j move beyond the array length?

A Step 9

B Step 10

C Step 11

D Step 8

💡 Hint

Look at the 'Pointer j (scan index)' column and the 'Action' description in the execution table.

If the array was [1,1,1,1,1], what would be the final value of i?

A 0

B 1

C 4

D 5

💡 Hint

Since all elements are duplicates, i stays at 0 as no new unique elements are found.

Concept Snapshot

Remove duplicates from a sorted array using two pointers:
- i tracks last unique element index
- j scans through array
- When nums[j] != nums[i], increment i and copy nums[j]
- Return i + 1 as new length
- Modifies array in-place without extra space

Full Transcript

This concept uses two pointers to remove duplicates from a sorted array in-place. Pointer i marks the position of the last unique element found. Pointer j scans the array from the second element onward. When nums[j] is different from nums[i], it means a new unique element is found. We increment i and copy nums[j] to nums[i]. This process continues until j reaches the end of the array. The function returns i + 1, which is the count of unique elements. The array is modified so that the first i+1 elements are unique, and duplicates beyond that are ignored.