C++ 如何从c+中的向量中删除重复项（具有原始值）+；

我编写的程序是为了从给定的一组数字中删除重复项。但我并没有得到所需的输出，而是每次都得到SIGSTP运行时错误。输入/输出格式如下： 输入：1 2 5 7 1 4 2 产出：574 我的代码如下：

#include <iostream>
#include<string>
#include <vector>
using namespace std;

int main() {
    // your code goes here
    int t;
    cin >> t;
    while(t--)
    {
        int n;
        cin >> n;
        vector<int> v_num;
        for(int i=0;i<n;i++)
        {
            int x;
            cin >> x;
            v_num.push_back(x);
       }
       vector<int>::iterator it;
       for(it=v_num.begin();it!=v_num.end();)
       {
           int val=*it;
           int flag=0;
           vector<int>:: iterator j;
           for(j=it+1;j!=v_num.end();)
           {
               if(val==*j)
               {
                   v_num.erase(j);
                   flag=1;
               }
               if(flag==0)
                  j++;
           }
           if(flag==1)
                { v_num.erase(it);
                 flag=1;}
           if(flag==0)
                 it++;
       }

        for(int i=0;i<v_num.size();i++)
           { cout <<v_num[i]<<endl;
            }
    }

}

#包括
#包括
#包括
使用名称空间std；
int main（）{
//你的密码在这里
int t；
cin>>t；
而（t--）
{
int n；
cin>>n；
向量v_num；
对于（int i=0；i>x；
v_数推回（x）；
}
向量：：迭代器；
for（it=v_num.begin（）；it！=v_num.end（）；）
{
int val=*it；
int标志=0；
向量：：迭代器j；
对于（j=it+1；j！=v_num.end（）；）
{
如果（val==*j）
{
v_num.erase（j）；
flag=1；
}
如果（标志==0）
j++；
}
如果（标志==1）
{v_num.擦除（它）；
标志=1；}
如果（标志==0）
it++；
}
对于（int i=0；i您真的不应该使用这样的向量。从向量中间删除会导致每次重新分配以下所有值。此时，所有迭代器都无效，这可能会导致您的运行时错误

简而言之，在向量上调用
erase
时，迭代器
it
和
j
都将无效，不应使用

您可以使用
std:：unique
或简单地使用
std:：set
来存储要开始的唯一值，同时避免使用向量，因为您只读取上面几行的值。
代码的问题是您删除了元素，然后使用了迭代器

e、 g

我只是从您的代码中复制并粘贴了它。您删除j，然后在下一次迭代中再次使用it，这很可能是无效的

从向量中删除会使迭代器无效

在这种情况下，您应该使用
std:：list
而不是
std:：vector
您可能需要这样的东西

vector<int> vec{1,1,2,3,4,4,2,5,6};
sort(begin(vec), end(vec));
auto last = unique(begin(vec), end(vec));
vec.erase(last, end(vec));

向量向量{1,1,2,3,4,4,2,5,6}；
排序（开始（vec），结束（vec））；
自动结束=唯一（开始（vec），结束（vec））；
向量擦除（最后，结束（向量））；

要使std:：unique工作，应事先对范围进行排序

编辑： 我知道我没有做问题所要求的，因为我在看其他答案。我设法编写了一个函数来返回一个具有唯一数字的向量，但它分配了临时计数数组，并最终从向量中复制唯一的元素。对此有何评论，请指教

template<typename T>
std::vector<T> erase_duplicated(const std::vector<T>& vec)
{
    const size_t n = vec.size();
    int* duplicates = new int[n];
    for(size_t i = 0; i < n; ++i) duplicates[i] = 0;

    for(size_t i = 0; i < n; ++i)
    {
        for(size_t j = i + 1; j < n; ++j)
            if(vec[i] == vec[j])
            {
               ++duplicates[i];
               ++duplicates[j];
            }
    }
    std::vector<T> temp;
    for(size_t i = 0; i < n; ++i)
    {
        if(!duplicates[i])
            temp.push_back(vec[i]);
    }
    delete [] duplicates;
    return temp;
}

模板
std:：vector erase_duplicated（常量std:：vector和vec）
{
常量大小n=向量大小（）；
int*duplicates=新的int[n]；
对于（大小i=0；i

如果我保存“it”在更改之前和更改之后，如果我将使用保存的值，那么它是否有效？我的意思是，每当我更改迭代器的值时，我都可以在更改之前保存它的值，然后再使用保存的值。不，您不能在迭代器中保存，它也将无效。在迭代器中保存的唯一方法是保存其索引和“还原”它就像

v_num.begin（）+index

oh一样，可以通过跳过计数器已经大于零的元素的迭代来优化它

template<typename T>
std::vector<T> erase_duplicated(const std::vector<T>& vec)
{
    const size_t n = vec.size();
    int* duplicates = new int[n];
    for(size_t i = 0; i < n; ++i) duplicates[i] = 0;

    for(size_t i = 0; i < n; ++i)
    {
        for(size_t j = i + 1; j < n; ++j)
            if(vec[i] == vec[j])
            {
               ++duplicates[i];
               ++duplicates[j];
            }
    }
    std::vector<T> temp;
    for(size_t i = 0; i < n; ++i)
    {
        if(!duplicates[i])
            temp.push_back(vec[i]);
    }
    delete [] duplicates;
    return temp;
}