LeetCode 第二十六題 刪除排序陣列中的重複項

給定一個排序陣列，你需要在原地刪除重複出現的元素，使得每個元素只出現一次，返回移除後陣列的新長度。
不要使用額外的陣列空間，你必須在原地修改輸入陣列並在使用 O(1) 額外空間的條件下完成。
示例 1:
給定陣列 nums = [1,1,2]
函式應該返回新的長度 2, 並且原陣列 nums 的前兩個元素被修改為 1, 2。
你不需要考慮陣列中超出新長度後面的元素。
示例 2:
給定 nums = [0,0,1,1,1,2,2,3,3,4],
函式應該返回新的長度 5, 並且原陣列 nums 的前五個元素被修改為 0, 1, 2, 3, 4。
你不需要考慮陣列中超出新長度後面的元素。

遍歷一遍陣列，如果當前數字和之前的數字相同，則將其刪除，然後將後續陣列元素向前移動。

Java

    public static int removeDuplicates(int[] nums) {
        if (nums == null || nums.length == 0||nums.length==1)
            return nums.length;
        int current_location = 1;
        for (int i = 1; i < nums.length; i++) {
            if
 
 (nums[current_location] == nums[current_location - 1]) {
                for (int j = current_location; j < nums.length - 1; j++) {
                    nums[j] = nums[j + 1];
                            } else {
                current_location++;
            }
        }
        return current_location;
    }
 

C++

class Solution
{
public:
    int removeDuplicates(vector<int>&nums)
    {
        if(nums.size()==0||nums.size()==1)return nums.size();
        int current_location=1;
        for(int i=1; i<nums.size(); i++)
        {
            if(nums[current_location]==nums[current_location-1])
            {
                for(int j=current_location; j<nums.size()-1; j++)
                {
                    nums[j]=nums[j+1];
                }
            }
            else
            {
                current_location++;
            }
        }
        return current_location;
    }
};

Python

組後一組測試未通過，因為超時了。有待改進。

class Solution(object):
    def removeDuplicates(self, nums):
        if len(nums) == 0 or len(nums) == 1:
            return len(nums)
        current_position = 1
        for i in range(len(nums)):
            if nums[current_position] == nums[current_position - 1]:
                for j in range(current_position, len(nums) - 1):
                    nums[j] = nums[j + 1]
            else:
                current_position += 1
                if current_position >= len(nums):
                    break
        return current_position

在網上看到了更加巧妙的演算法，整個時間複雜度只有O(n)，它主要是使用了兩個座標i和j,一個跑的快一點，一個跑的慢一點，下面是其程式碼，學習學習。

public int removeDuplicates(int[] nums) {
    if (nums.length == 0) return 0;
    int i = 0;
    for (int j = 1; j < nums.length; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}