vector的erase()方法遍历删除元素迭代器失效问题、及删除最后一个元素迭代器失效问题）

1.删除指定范围的元素
vector删除元素之pop_back(),erase(),remove()
向量容器vector的成员函数pop_back()可以删除最后一个元素.

而函数erase()可以删除由一个iterator指出的元素，也可以删除一个指定范围的元素。

还可以采用通用算法remove()来删除vector容器中的元素.

不同的是：采用remove一般情况下不会改变容器的大小，而pop_back()与erase()等成员函数会改变容器的大小。

2.删除指定大小的元素
1. 方法一：
由于上面的删除方法都是只能删除指定的迭代器指定的位置元素，所以如果需要删除指定大小的元素则需要先找到其迭代器，不同于map(map有find方法），vector本身是没有find这一方法，其find是依靠algorithm来实现的。
给个例子：

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

template<typename T>
inline void vectorDel(std::vector<T>& vec, T a) {
? ? auto it = std::find(vec.begin(), vec.end(), a);
? ? vec.erase(it);
}

int main()
{
?? ?vector<int> vec;
?? ?for(int i=0;i<10;i++){
?? ??? ?vec.push_back(i);
?? ?}
?? ?for(int i=0;i<vec.size();i++){
?? ??? ?cout << vec[i] <<' ';
?? ?}
?? ?cout<<endl;
?? ?// 1.
?? ?vector<int>::iterator it = find(vec.begin(), vec.end(), 2);
?? ?// vec.erase(vec.begin()+5);//erase the 6th element
?? ?vec.erase(it);
?? ?// 2.
?? ?vectorDel<int>(vec, 3);
?? ?for(int i=0;i<vec.size();i++){
?? ??? ?cout << vec[i] << ' ';
?? ?}
?? ?cout<<endl;
?? ?return 0;
}

运行结果：

0 1 2 3 4 5 6 7 8 9?
0 1 4 5 6 7 8 9

方法二：
摘抄自：对vector删除元素的效率比较
最近在看github上的开源代码，看到了vector删除元素的操作，如（1）所示
（1）、先用swap把要删除的元素和vector里最后一个元素交换位置，然后把最后一个元素pop_back

std::swap(*it, observers_.back());
observers_.pop_back();

我平时删除vector上的元素跟（2）是一样的
（2）、先用find查找元素，然后用erase删除元素

Iterator it = std::find(observers_.begin(), observers_.end(), x);
observers_.erase(it);

1的效率高，2删除元素后需要把后面的元素依次向前移动，但有时会要求不能改变vector中元素顺序，此时只能使用2
3.C++20 std::erase, std::erase_if (std::vector)
std::erase, std::erase_if (std::vector)中给了解释和例子。

注意点
erase()方法遍历删除某些元素迭代器失效问题、及删除最后一个元素迭代器失效问题）
给一个例子：

template<typename T = int>
bool remove_array(std::vector<T> &array, T v){
? ? typename std::vector<T>::iterator it = std::find(array.begin(), array.end(), v);
? ? if(it == array.end()){
? ? ? ? return false;
? ? }
? ? std::swap(*it, array.back());
? ? array.pop_back();
? ? return true;
}
void test_delete_in_vector() {
? // 例1
? std::vector<int> array;
? array.push_back(26);
? remove_array(array, 26);
? for (auto v : array) {
? ? std::cout << "array: " << v << std::endl;
? }
? // 例2
? std::vector<int> test_vec;
? for(int i = 0; i < 10; i++) {
? ? test_vec.emplace_back(i);
? }
? auto iter= test_vec.begin();
? while(iter!=test_vec.end()) {
? ? ? if((*iter) % 2 == 1) {
? ? ? ? ? iter = test_vec.erase(iter); // 如果删除的是最后一个元素，则返回的是迭代器为空，所以不能++
? ? ? } else {
? ? ? ? ? ++iter;
? ? ? }
? }
? for (auto v : test_vec) {
? ? std::cout << v << std::endl;
? }
}

4.删除重复元素

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
? ? std::vector<int> numbers = {1, 2, 2, 3, 3, 3, 4, 5, 5, 6};

? ? // 使用 std::unique 去除相邻重复元素
? ? auto new_end = std::unique(numbers.begin(), numbers.end());

? ? // 使用容器的 erase 方法删除重复元素
? ? numbers.erase(new_end, numbers.end());

? ? // 打印结果
? ? std::cout << "Numbers after removing duplicates: ";
? ? for (const auto& num : numbers) {
? ? ? ? std::cout << num << " ";
? ? }
? ? std::cout << std::endl;

? ? return 0;
}

/*
output:
Numbers after removing duplicates: 1 2 3 4 5 6?
*/
?

1.vector迭代器失效问题
什么情况下会失效？以及失效的原因
vector是个连续内存存储的容器，如果vector容器的中间某个元素被删除或从中间插入一个元素， 有可能导致内存空间不够用而重新分配一块大的内存

造成失效的其中一原因：
? ? ? ? 是因为内存的重新分配, 保留下来的迭代器不再指向容器中原来的元素

还有一种是删除元素，迭代器指向的空间自然就是一个无效的地址，无法再使用
使得vector迭代器失效的操作有：

（1）执行erase方法时，指向删除节点及其之后的全部迭代器均失效；
? ? ? ? ?

那么我们更新迭代器试试？ ok了

但是，请看下图：一样的代码，只不过vector里的元素最后一个改为0了，报错了！

为什么报错呢？

原因：只有要删除的是最后一个元素，第一套代码才会暴露问题，因为删除最后一个元素，返回下一个迭代器是个空，对空指针进行++操作肯定崩溃

正确的写法如下：这样避免删除最后一个元素还对空迭代器操作

#include<vector>
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {

        if(nums.size()>100)
        {
            cout<<"0 <= nums.length <= 100"<<endl;
            return nums.size();
        }
        if (val<0 || val>100)
        {
            cout<<"0 <= val <= 100"<<endl;
            return nums.size();
        }

		for (vector<int>::iterator iter = nums.begin(); iter != nums.end(); )
		{
			if (val == *iter)
			{
				swap(*iter,nums.back() );
				nums.pop_back();
			}
            else
            {
                iter++;
            }
			
		}

		return nums.size();

    }
};