Remove Duplicates Sorted Array Java | Fresher Interview

Direct Answer

Use a slow pointer marking the last unique element and a fast pointer scanning ahead. When a[fast] != a[slow], copy a[fast] to a[slow+1] and advance slow. Return slow + 1 as the new length. This is O(n) time, O(1) space.

Deep Dive & Architecture

Because the array is sorted, equal values are adjacent. Keep a slow write index at the last unique value, and let a fast index scan the remaining items. When a[fast] differs from a[slow], advance slow and copy the new value there.

Worked example: [0, 0, 1, 1, 2]

Slow starts at index 0. Fast index 1 is another 0, so skip it. Fast index 2 is 1, so advance slow to 1 and write 1, giving useful prefix [0, 1]. Skip the next 1. When fast reaches 2, advance slow to 2 and write it. Return slow + 1 = 3; the valid result is the prefix [0, 1, 2].

The method does not need to erase or resize the rest of the array. Values after the returned length are unspecified and the caller must ignore them. An empty array returns length 0.

Both pointers move only forward, so time is O(n) and extra space is O(1). Creating a set or a new list would violate the in-place requirement. The sorted-order assumption is essential; on unsorted input, equal values are not grouped and this comparison cannot identify all duplicates.

Code Example

public class DuplicateRemover {
    public int removeDuplicates(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        int slow = 0;                          // last unique position
        for (int fast = 1; fast < nums.length; fast++) {
            if (nums[fast] != nums[slow]) {    // found a new unique value
                slow++;
                nums[slow] = nums[fast];       // write to next unique slot
            }
        }
        return slow + 1;                       // new logical length
    }

    public static void main(String[] args) {
        int[] nums = {1, 1, 2, 2, 2, 3, 4, 4};
        int len = new DuplicateRemover().removeDuplicates(nums);
        System.out.println("New length: " + len);   // 4 -> [1, 2, 3, 4, ...]
    }
}

Common Mistakes & Pitfalls

• Creating a new ArrayList: collecting uniques in a new list violates the in-place constraint.
• Trying to delete elements: shifting everything left on each duplicate is O(n^2) — just overwrite and return the new length.
• Misunderstanding the return value: you return the count; elements beyond it are ignored, so there's no need to truncate or zero them.
• Starting slow at 1: start slow at 0 — the first element is always unique.