Remove Duplicates from Sorted Array Two Pointer in DSA C++ - Build from Scratch

Remove Duplicates from Sorted Array Two Pointer

📖 Scenario: You have a sorted list of numbers that may contain duplicates. You want to keep only unique numbers in the list, removing any repeated numbers.This is like cleaning a guest list where each name appears only once, so you don't invite the same person twice.

🎯 Goal: Build a program that removes duplicates from a sorted array using the two-pointer technique. The program will modify the array in place and print the array after duplicates are removed.

📋 What You'll Learn

Create a vector called nums with the exact values: {1, 1, 2, 2, 3, 4, 4, 5}

Create an integer variable called n to store the size of nums

Use two integer pointers i and j to remove duplicates in place

Print the modified nums vector elements separated by spaces after duplicates are removed

💡 Why This Matters

🌍 Real World

Removing duplicates from sorted data is common in cleaning lists like contact lists, event logs, or sorted records to avoid repeated entries.

💼 Career

Understanding two-pointer techniques and in-place array modification is useful for coding interviews and optimizing data processing tasks.

1

Create the sorted vector with duplicates

Create a vector called nums with the exact values {1, 1, 2, 2, 3, 4, 4, 5}.

DSA C++

#include 
#include 

int main() {
    // Create vector nums with values {1, 1, 2, 2, 3, 4, 4, 5}
    // Your code here

    return 0;
}

Hint

Use std::vector<int> nums = {1, 1, 2, 2, 3, 4, 4, 5}; to create the vector.

2

Create a variable for the vector size

Create an integer variable called n and set it to the size of the vector nums.

DSA C++

#include 
#include 

int main() {
    std::vector nums = {1, 1, 2, 2, 3, 4, 4, 5};
    // Create int n to store size of nums
    // Your code here

    return 0;
}

Hint

Use int n = nums.size(); to get the vector size.

3

Use two pointers to remove duplicates in place

Use two integer pointers i and j to remove duplicates from nums in place. Initialize i to 0 and loop j from 1 to n - 1. If nums[j] is not equal to nums[i], increment i and set nums[i] to nums[j]. After the loop, resize nums to i + 1.

DSA C++

#include 
#include 

int main() {
    std::vector nums = {1, 1, 2, 2, 3, 4, 4, 5};
    int n = nums.size();

    // Use two pointers i and j to remove duplicates
    // Your code here

    return 0;
}

Hint

Use a for loop with j starting at 1 and compare nums[j] with nums[i]. Update i and nums[i] when different.

4

Print the modified vector after removing duplicates

Print all elements of the modified vector nums separated by spaces on a single line.

DSA C++

#include 
#include 

int main() {
    std::vector nums = {1, 1, 2, 2, 3, 4, 4, 5};
    int n = nums.size();

    int i = 0;
    for (int j = 1; j < n; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    nums.resize(i + 1);

    // Print the elements of nums separated by spaces
    // Your code here

    return 0;
}

Hint

Use a for loop to print each element followed by a space, then print a newline.

Practice

1. What is the main purpose of the two-pointer technique in removing duplicates from a sorted array?

easy

A. To track unique elements and overwrite duplicates in-place

B. To sort the array again after removing duplicates

C. To create a new array with duplicates removed

D. To count the total number of duplicates only

Solution

1. Step 1: Understand the two-pointer roles

   One pointer tracks the position to place unique elements, the other scans the array.

2. Step 2: Overwrite duplicates in-place

   When a new unique element is found, it is placed at the tracked position, replacing duplicates.

3. Final Answer:

   To track unique elements and overwrite duplicates in-place -> Option A

4. Quick Check:

   Two-pointer technique = overwrite duplicates [OK]

Hint: Two pointers: one scans, one writes unique values [OK]

Common Mistakes:

• Thinking it creates a new array instead of modifying in-place
• Assuming it sorts the array again
• Confusing counting duplicates with removing them

2. Which of the following is the correct syntax to initialize the two pointers for removing duplicates from a sorted array nums in C++?

easy

A. int i = 0, j = 1;

B. int i = 1, j = 0;

C. int i = 0, j = 0;

D. int i = 1, j = 1;

Solution

1. Step 1: Identify pointer roles

   Pointer i tracks the last unique element index, starting at 0; j scans from 1.

2. Step 2: Initialize pointers accordingly

   Set i = 0 and j = 1 to start comparing from the second element.

3. Final Answer:

   int i = 0, j = 1; -> Option A

4. Quick Check:

   i=0, j=1 start positions [OK]

Hint: Start i at 0, j at 1 to compare neighbors [OK]

Common Mistakes:

• Starting both pointers at 0
• Swapping i and j initialization
• Starting j before i

3. What will be the output length after removing duplicates using the two-pointer method on the sorted array nums = {1, 1, 2, 3, 3, 4}?

medium

A. 3

B. 4

C. 5

D. 6

Solution

1. Step 1: Identify unique elements in order

   Unique elements are 1, 2, 3, 4.

2. Step 2: Count unique elements

   There are 4 unique elements, so the length after removal is 4.

3. Final Answer:

   4 -> Option B

4. Quick Check:

   Unique count = 4 [OK]

Hint: Count unique numbers in sorted array [OK]

Common Mistakes:

• Counting duplicates as unique
• Confusing length with original array size
• Off-by-one errors in counting

4. Identify the error in the following C++ code snippet for removing duplicates from a sorted array nums:

int removeDuplicates(vector<int>& nums) {
    int i = 0, j = 1;
    while (j < nums.size()) {
        if (nums[i] != nums[j]) {
            i++;
            nums[i] = nums[j];
        }
        j++;
    }
    return i;
}

medium

A. The loop should use for instead of while

B. Pointers i and j should start at 1 and 0 respectively

C. The condition should be nums[i] == nums[j] instead of !=

D. Return value should be i + 1, not i

Solution

1. Step 1: Understand pointer i meaning

   Pointer i is index of last unique element, so length is i + 1.

2. Step 2: Check return statement

   Returning i alone gives index, not count; must return i + 1 for length.

3. Final Answer:

   Return value should be i + 1, not i -> Option D

4. Quick Check:

   Length = last index + 1 [OK]

Hint: Return i + 1 as length, not i [OK]

Common Mistakes:

• Returning i instead of i + 1
• Swapping pointer initializations
• Using wrong comparison operator

5. Given a sorted array nums = {0, 0, 1, 1, 1, 2, 2, 3, 3, 4}, what will be the state of the array after applying the two-pointer method to remove duplicates, and what is the new length?

hard

A. Array: {0, 1, 1, 2, 3, 4, _, _, _, _}, Length: 4

B. Array: {0, 0, 1, 1, 2, 2, 3, 3, 4, 4}, Length: 6

C. Array: {0, 1, 2, 3, 4, _, _, _, _, _}, Length: 5

D. Array: {0, 1, 2, 3, 4, 5, _, _, _, _}, Length: 6

Solution

1. Step 1: Identify unique elements in order

   Unique elements are 0, 1, 2, 3, 4.

2. Step 2: Overwrite duplicates in-place

   Using two pointers, these unique elements overwrite the start of the array.

3. Step 3: Determine new length

   There are 5 unique elements, so length is 5.

4. Final Answer:

   Array: {0, 1, 2, 3, 4, _, _, _, _, _}, Length: 5 -> Option C

5. Quick Check:

   Unique elements = 5, array start updated [OK]

Hint: Unique elements overwrite start, length = count unique [OK]

Common Mistakes:

• Not overwriting duplicates correctly
• Miscounting unique elements
• Assuming array length stays same