Welcome to Subscribe On Youtube
26. Remove Duplicates from Sorted Array
Description
Given an integer array nums
sorted in nondecreasing order, remove the duplicates inplace such that each unique element appears only once. The relative order of the elements should be kept the same. Then return the number of unique elements in nums
.
Consider the number of unique elements of nums
to be k
, to get accepted, you need to do the following things:
 Change the array
nums
such that the firstk
elements ofnums
contain the unique elements in the order they were present innums
initially. The remaining elements ofnums
are not important as well as the size ofnums
.  Return
k
.
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^{4}
100 <= nums[i] <= 100
nums
is sorted in nondecreasing order.
Solutions
Solution 1: Single Pass
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[k1]$, we place $x$ in the position of $nums[k]$, and then increment $k$ by $1$. Otherwise, $x$ is the same as $nums[k1]$, 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.

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) { nums.erase(unique(nums.begin(), nums.end()), nums.end()); return nums.size(); } };

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

func removeDuplicates(nums []int) int { k := 0 for _, x := range nums { if k == 0  x != nums[k1] { 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; }

/** * @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; };

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; } }

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; } }

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 } }