26. Remove Duplicates from Sorted Array

Description

Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. The relative order of the elements should be kept the same.

Consider the number of unique elements in nums to be k. After removing duplicates, return the number of unique elements k.

The first k elements of nums should contain the unique numbers in sorted order. The remaining elements beyond index k - 1 can be ignored.

Custom Judge:

The judge will test your solution with the following code:

int[] nums = [...]; // Input array
int[] expectedNums = [...]; // The expected answer with correct length

int k = removeDuplicates(nums); // Calls your implementation

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

If all assertions pass, then your solution will be accepted.

Example 1:

Input: nums = [1,1,2]
Output: 2, nums = [1,2,_]
Explanation: Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively.
It does not matter what you leave beyond the returned k (hence they are underscores).

Example 2:

Input: nums = [0,0,1,1,1,2,2,3,3,4]
Output: 5, nums = [0,1,2,3,4,_,_,_,_,_]
Explanation: Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively.
It does not matter what you leave beyond the returned k (hence they are underscores).

Constraints:

1 <= nums.length <= 3 * 10⁴
-100 <= nums[i] <= 100
nums is sorted in non-decreasing order.

Solutions

Solution 1: Single Pass

Thinking

The first idea is a hash set of seen values, then write them back. \(n \le 3\times 10^4\) would pass, but the problem wants an in-place rewrite, so the extra table is wasteful.

The bottleneck is the "have we seen this" query. The array is non-decreasing, so equals sit next to each other and a global lookup is unnecessary.

Compare \(x\) with the last value already written. If it differs (or nothing has been written yet), write it at index \(k\); otherwise skip.

\(k\) is both the write pointer and the unique length. One pass, \(O(1)\) extra space.

We use a variable \(k\) to record the current length of the processed array. Initially, \(k=0\) represents an empty array.

Then we traverse the array from left to right. For each element \(x\) we encounter, if \(k=0\) or \(x \neq nums[k-1]\), we place \(x\) in the position of \(nums[k]\), and then increment \(k\) by \(1\). Otherwise, \(x\) is the same as \(nums[k-1]\), so we skip this element. Continue to traverse until the entire array is traversed.

In this way, when the traversal ends, the first \(k\) elements in \(nums\) are the answer we are looking for, and \(k\) is the length of the answer.

The time complexity is \(O(n)\), and the space complexity is \(O(1)\). Here, \(n\) is the length of the array.

Supplement:

The original problem requires that the same number appear at most once. We can extend it to keep at most \(k\) identical numbers.

Since the same number can be kept at most \(k\) times, we can directly keep the first \(k\) elements of the original array;
For the following numbers, the premise of being able to keep them is: the current number \(x\) is compared with the last \(k\)th element of the previously retained numbers. If they are different, keep them, otherwise skip them.

Similar problems:

80. Remove Duplicates from Sorted Array II

Python3JavaC++GoTypeScriptRustJavaScriptC#PHP

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        k = 0
        for x in nums:
            if k == 0 or x != nums[k - 1]:
                nums[k] = x
                k += 1
        return k

class Solution {
    public int removeDuplicates(int[] nums) {
        int k = 0;
        for (int x : nums) {
            if (k == 0 || x != nums[k - 1]) {
                nums[k++] = x;
            }
        }
        return k;
    }
}

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int k = 0;
        for (int x : nums) {
            if (k == 0 || x != nums[k - 1]) {
                nums[k++] = x;
            }
        }
        return k;
    }
};

func removeDuplicates(nums []int) int {
    k := 0
    for _, x := range nums {
        if k == 0 || x != nums[k-1] {
            nums[k] = x
            k++
        }
    }
    return k
}

function removeDuplicates(nums: number[]): number {
    let k: number = 0;
    for (const x of nums) {
        if (k === 0 || x !== nums[k - 1]) {
            nums[k++] = x;
        }
    }
    return k;
}

impl Solution {
    pub fn remove_duplicates(nums: &mut Vec<i32>) -> i32 {
        let mut k = 0;
        for i in 0..nums.len() {
            if k == 0 || nums[i] != nums[k - 1] {
                nums[k] = nums[i];
                k += 1;
            }
        }
        k as i32
    }
}

/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function (nums) {
    let k = 0;
    for (const x of nums) {
        if (k === 0 || x !== nums[k - 1]) {
            nums[k++] = x;
        }
    }
    return k;
};

public class Solution {
    public int RemoveDuplicates(int[] nums) {
        int k = 0;
        foreach (int x in nums) {
            if (k == 0 || x != nums[k - 1]) {
                nums[k++] = x;
            }
        }
        return k;
    }
}

class Solution {
    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function removeDuplicates(&$nums) {
        $k = 0;
        foreach ($nums as $x) {
            if ($k == 0 || $x != $nums[$k - 1]) {
                $nums[$k++] = $x;
            }
        }
        return $k;
    }
}

26. Remove Duplicates from Sorted Array

Description

Solutions

Solution 1: Single Pass

Comments