C++ 删除向量c++；

我试图删除向量中相同的整数。我的目标是只复制一份。我写了一个简单的代码，但它不能正常工作。有人能帮忙吗？提前谢谢

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

int main()

{   

int a = 10, b = 10 , c = 8, d = 8, e = 10 , f = 6;
vector<int> vec;

vec.push_back(a);
vec.push_back(b);
vec.push_back(c);
vec.push_back(d);
vec.push_back(e);
vec.push_back(f);


for (int i=vec.size()-1; i>=0; i--)
{
    for(int j=vec.size()-1; j>=0; j--)
    {
        if(vec[j] == vec[i-1])
            vec.erase(vec.begin() + j);
    }
}   

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

return 0;
}

#包括
#包括
使用名称空间std；
int main（）
{   
INTA=10，b=10，c=8，d=8，e=10，f=6；
向量向量机；
向量推回（a）；
向量推回（b）；
向量推回（c）；
向量推回（d）；
向量推回（e）；
向量推回（f）；
对于（int i=vec.size（）-1；i>=0；i--）
{
对于（int j=vec.size（）-1；j>=0；j--）
{
if（vec[j]==vec[i-1]）
向量擦除（向量开始（）+j）；
}
}   
对于（int i=0；i不要为此使用列表。使用集合：

 #include <set>
 ...
 set<int> vec;

#包括
...
设置vec；

这将通过不添加元素（如果元素已经存在）来确保没有重复项。
代码的问题在于：

for(int j=vec.size()-1; j>=0; j--)
{
    if(vec[j] == vec[i-1])
        vec.erase(vec.begin() + j);
}

将会有一段时间，
j==i-1
这会扼杀你的算法，也会有一段时间，
i-1<0
所以你会得到一个越界异常

您可以做的是更改for循环条件：

for (int i = vec.size() - 1; i>0; i--){
    for(int j = i - 1; j >= 0; j--){
        //do stuff
    }
}

这样，比较的两个变量将永远不会相同，索引将始终至少为0。
如果需要保存数字的初始顺序，可以使用helper
set
结构创建一个删除重复项的函数：

void removeDuplicates( vector<int>& v )
{
    set<int> s;
    vector<int> res;
    for( int i = 0; i < v.size(); i++ ) {
        int x = v[i];
        if( s.find(x) == s.end() ) {
            s.insert(x);
            res.push_back(x);
        }
    }
    swap(v, res);
}

void removeDuplicates（向量&v）
{
设置s；
向量res；
对于（int i=0；i
其他人已经指出了
std:：set
。这当然是简单易行的——但它可能相当慢（比
std:：vector
慢一点），主要是因为（像链表一样）它由单独分配的节点组成，通过指针链接在一起形成一个平衡的树1

您可以（通常）通过使用
std:：unordered_set
而不是
std:：set
来改进这一点。这使用哈希表2而不是树来存储数据，因此它通常使用连续存储，并给出O（1）预期访问时间，而不是树预期的O（logn）

另一种通常更快的方法是收集向量中的数据，然后对数据进行排序，并使用
std:：unique
消除重复项。当您有两个不同的操作阶段时，这往往是最好的方法：首先收集所有数据，然后需要删除重复项。如果您经常在添加/删除数据之间进行交替，则d需要一个重复的自由集，那么像
std:：set
或
std:：unordered_set
这样的东西可能更有用，它可以在任何时候保持集合不重复

所有这些都会影响项目的顺序。
std:：set
始终维护按定义顺序排序的项目。使用
std:：unique
时，您需要对数据进行显式排序。使用
std:：unordered_set
时，您可以按照任意顺序对项目进行排序，既不是原始顺序，也不是排序顺序

如果您需要保持原始顺序，但没有重复项，则通常需要存储两次数据。例如，当您需要添加新项目时，您尝试将其插入到
std:：unordered_集
，然后如果且仅当成功时，将其添加到向量中


从技术上讲，作为树的实现并不是严格要求的，但这是我所知道的唯一能够满足要求的可能性，我所知道的所有实现都是基于树的

同样，其他实现在理论上可能是可行的，但我知道所有这些都使用了哈希——但在本例中，暴露了足够多的实现，因此避免使用哈希表可能会更加困难

如果删除重复，则首先对数组排序会更容易。下面的代码使用两种不同的方法来删除重复：一种使用内置的C++算法，另一种使用循环。
#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>

using namespace std;

int main() {
    int a = 10, b = 10 , c = 8, d = 8, e = 10 , f = 6;
    vector<int> vec;
    vec.push_back(a);
    vec.push_back(b);
    vec.push_back(c);
    vec.push_back(d);
    vec.push_back(e);
    vec.push_back(f);

    // Sort the vector
    std::sort(vec.begin(), vec.end());

    // Remove duplicates (v1)
    std::vector<int> result;
    std::unique_copy(vec.begin(), vec.end(), std::back_inserter(result));

    // Print results
    std::cout << "Result v1: ";
    std::copy(result.begin(), result.end(), std::ostream_iterator<int>(cout, " "));
    std::cout << std::endl;

    // Remove duplicates (v2)
    std::vector<int> result2;
    for (int i = 0; i < vec.size(); i++) {
        if (i > 0 && vec[i] == vec[i - 1])
            continue;
        result2.push_back(vec[i]);
    }

    // Print results (v2)
    std::cout << "Result v2: ";
    std::copy(result2.begin(), result2.end(), std::ostream_iterator<int>(cout, " "));
    std::cout << std::endl;

    return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
int main（）{
INTA=10，b=10，c=8，d=8，e=10，f=6；
向量向量机；
向量推回（a）；
向量推回（b）；
向量推回（c）；
向量推回（d）；
向量推回（e）；
向量推回（f）；
//对向量排序
排序（vec.begin（），vec.end（））；
//删除重复项（v1）
std：：向量结果；
std:：unique_copy（vec.begin（）、vec.end（）、std:：back_inserter（result））；
//打印结果
std:：cout的范围主体不能更改其迭代的序列的大小

您可以在推回之前删除重复项

void push(std::vector<int> & arr, int n)
{

    for(int i = 0; i != arr.size(); ++i)
    {
        if(arr[i] == n) 
        {
            return;
        }
    }
    arr.push_back(n);
}

... ... 

push(vec, a);

push(vec, b);

push(vec, c);
... 

无效推送（std:：vector&arr，int n）
{
对于（int i=0；i！=arr.size（）；+i）
{
如果（arr[i]==n）
{
返回；
}
}
arr.推回（n）；
}
... ... 
推（vec，a）；
推（vec，b）；
推（vec，c）；
... 
如果你不想重复，为什么不使用
std:：set
来代替呢？@Nawaz:也许他需要连续存储，或者更快的迭代性能。或者容器不应该永远都有重复项，而应该在特定的时间删除它们。有很多理由不盲目地用
std:：set替换它）谢谢你的回复，但我只能使用loops@user2878007：那又怎样？你可以在任何容器中循环。顺便说一句，
vec[i-1]存在严重问题
当i==0时，您编写的代码不完整，无法修改work@user2878007你想让我为你重写整个main方法吗？当然不想，但请帮我在你的循环中编写部分。你是说
//dostuff
部分吗？如果是正确的，请投票表决或将其标记为答案。谢谢！我想还有一些问题需要解决ng缺失，因为当我添加另一个整数时，它不起作用