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

Когда вы увеличиваете j, затем erase элемент там, элементы, начинающиеся с j + 1, перемещаются вниз. Вы пропускаете элемент, увеличивая его.

Лучшим подходом было бы просто скопировать неповторяющиеся элементы из одного итератора в другой и установить новую длину в конце основного цикла. Ваш текущий подход потенциально O (n ^ 2), слишком медленный для практического использования.

Думаю, это то, что вам нужно. Эта функция перебирает массив от хвоста к голове и считает одинаковые значения. Затем выполняет сдвиг уже уникальных значений на уникальное. Это не меняет фактический размер вектора, поскольку это, вероятно, потребует перераспределения памяти внутри вектора.

int removeDuplicates(vector<int> &vec) {
    int currentVal = vec.size() - 1;
    int uniqueNumber = 0;

    while (currentVal >= 0) {
        ++uniqueNumber;
        int sameVal = currentVal;
        while (sameVal > 0 && vec[sameVal - 1] == vec[currentVal])
            --sameVal;

        int shiftSize = uniqueNumber;
        for (int k = 1; k < shiftSize; ++k) {
            vec[sameVal + k] = vec[currentVal + k];
        }

        currentVal = sameVal - 1;
    }
    return uniqueNumber;
}

Вас просят использовать массив. Хотя вектор во многом похож, это не одно и то же. Взгляните на приведенный ниже пример кода.

Вдобавок вас просят оставить выделенную память таким же. Вы не можете гарантировать, что при использовании вектора его размер может увеличиваться / уменьшаться после добавления / удаления элементов, а при удалении элемента данные в массиве за вектором будут перераспределены и перезаписаны.

int main()
{

    int arr[14] = {0,0,0,0,0,4,4,4,4,5,5,5,7,9};
    int last_non_duplicate_index = 0;
    int current_index = 0;
    int size = 14;
    int new_size = size;
    bool is_last_value = false;

    // you can use for interchangeably
    while(!is_last_value)
    {
        current_index++; // move one position ahead
        if(current_index < size) // out of bonds check
        {
            if(arr[last_non_duplicate_index] != arr[current_index]) // value at position of current index is different
            {
                last_non_duplicate_index++; // increase index of the last value which was not a duplicate by one
                arr[last_non_duplicate_index] = arr[current_index]; // write at that index 
                // e.g. if last index was 0 -> increase it to 1 and rewrite whatsever under arr[1] (current index)
            }
            else // values are the same
            { 
                new_size--; // devrease the size
            }
        }
        else
        {
            is_last_value = true; // current_index >= size -> out of bonds
        }
    }

    for (int i = 0; i < new_size; i++)
    {
        std::cout << "arr[" << i << "]" << " = " << arr[i] << std::endl;
    }
    std::cout << "New size: " << new_size << std::endl;
    return 0;
}

Вы можете сделать это с помощью таких итераторов:

#include<iostream>
#include<vector>

using namespace std;

int removeDuplicates(vector<int> &A) {
    int m = A.size();
    if(m <= 1) return m;

    for (auto it1 = A.begin(); it1 != A.end(); it1++) {
        for (auto it2 = it1 + 1; it2 != A.end();) {
            if (*it1 == *it2) {
                it2 = A.erase(it2);
            } else {
                it2++;
            }
        }
    }

    return A.size();
}

int main()
{
    vector<int> vec = { 0, 0, 0, 0, 0, 0, 0, 4, 4, 7, 7, 7, 7, 9 };
    cout << "ans=" << removeDuplicates(vec);
    return 0;
}