LeetCode - удалить дубликаты из отсортированного массива

Постановка задачи

Учитывая отсортированный массив Nums , удалить дубликаты на месте, так что каждый элемент появляется только один раз и возвращает новую длину.

Не распределяйте дополнительное место для другого массива, Вы должны сделать это путем изменения массива ввода на месте с O (1) дополнительная память.

Заявление о проблеме, взятое из: https://leetcode.com/problems/remove-duplicates-from-sorted-array

Пример 1:

Input: nums = [1, 1, 2]
Output: 2, nums = [1, 2]
Explanation: Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively. It doesn't matter what you leave beyond the returned length.

Пример 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 length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively. It doesn't matter what values are set beyond the returned length.

Ограничения:

- 0 <= nums.length <= 3 * 10^4
- -10^4 <= nums[i] <= 10^4
- nums is sorted in ascending order.

Объяснение

Грубая сила

Что ж, проблема говорит о том, чтобы решить его без какого -либо дополнительного пространства, но первый подход Brute Force, который мы получаем, состоит в том, чтобы подсчитать возникновение различных элементов и хранить его в хэш (или объекте).

Ключ будет элемент массива, и значение будет количество раз, когда элемент появлялся в массиве.

Затем мы повторяем хеш и храним ключи в новом массиве.

Решение требует дополнительного места для нового массива и нового хэша.

Два указателя

Чтобы улучшить вышеуказанный подход, мы можем воспользоваться преимуществами отсортированного массива здесь. Мы можем использовать два указателя i и Дж . Мы продолжаем увеличивать J До времени Nums [i] [j] Анкет

Давайте проверим алгоритм ниже:

- return if nums size <= 1

- set i = 0

- Loop for j = 1; j < nums.size(); j++
  - if nums[j] != nums[i]
    - i++
    - nums[i] = nums[j]

- return i + 1

Временная сложность приведенного выше подхода – O (n) И сложность пространства – это O (1) .

C ++ Решение

class Solution {
public:
    int removeDuplicates(vector& nums) {
        if(nums.size() <= 1){
            return nums.size();
        }

        int i = 0;

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

        return i + 1;
    }
};

Голанг раствор

func removeDuplicates(nums []int) int {
    length := len(nums)

    if length <= 1 {
        return length
    }

    i := 0

    for j := 1; j < length; j++ {
        if nums[i] != nums[j] {
            i++
            nums[i] = nums[j]
        }
    }

    return i + 1
}

JavaScript Solution

var removeDuplicates = function(nums) {
    const length = nums.length;

    if( length <= 1 ){
        return length;
    }

    let i = 0;

    for(let j = 1; j < length; j++){
        if( nums[i] != nums[j] ){
            i++;
            nums[i] = nums[j];
        }
    }

    return i + 1;
};

Давайте сушат наш алгоритм, чтобы увидеть, как работает решение.

nums = [0,0,1,1,1,2,2,3,3,4]

Step 1: length = nums.size()
               = 10

Step 2: length <= 1
            10 <= 1
            false

Step 3: i = 0

Step 4: Loop for j = 1; 1 < 10
        nums[i] != nums[j]
        nums[0] != nums[1]
        0 != 0
        false

        j++
        j = 2

Step 5: Loop for j = 2; 2 < 10
        nums[i] != nums[j]
        nums[0] != nums[2]
        0 != 1
        true

        i++
        i = 1

        nums[i] = nums[j]
        nums[1] = nums[2]
        nums[1] = 1

        j++
        j = 3

Step 6: Loop for j = 3; 3 < 10
        nums[i] != nums[j]
        nums[1] != nums[3]
        1 != 1
        false

        j++
        j = 4

Step 7: Loop for j = 4; 4 < 10
        nums[i] != nums[j]
        nums[1] != nums[4]
        1 != 1
        false

        j++
        j = 5

Step 8: Loop for j = 5; 5 < 10
        nums[i] != nums[j]
        nums[1] != nums[5]
        1 != 2
        true

        i++
        i = 2

        nums[i] = nums[j]
        nums[2] = nums[5]
        nums[2] = 2

        j++
        j = 6

Step 9: Loop for j = 6; 6 < 10
        nums[i] != nums[j]
        nums[2] != nums[6]
        2 != 2
        false

        j++
        j = 7

Step 10: Loop for j = 7; 7 < 10
         nums[i] != nums[j]
         nums[2] != nums[7]
         2 != 3
         true

         i++
         i = 3

         nums[i] = nums[j]
         nums[3] = nums[7]
         nums[3] = 3

         j++
         j = 8

Step 11: Loop for j = 8; 8 < 10
         nums[i] != nums[j]
         nums[3] != nums[8]
         3 != 3
         false

         j++
         j = 9

Step 12: Loop for j = 9; 9 < 10
         nums[i] != nums[j]
         nums[3] != nums[9]
         3 != 4
         true

         i++
         i = 4

         nums[i] = nums[j]
         nums[4] = nums[9]
         nums[4] = 4

         j++
         j = 10

Step 13: Loop for j = 10; 10 < 10
         false

Step 14: return i + 1
         return 4 + 1 = 5

Оригинал: “https://dev.to/_alkesh26/leetcode-remove-duplicates-from-sorted-array-2p9f”