Deleting like elements in two vectors C++ - c++

Question

I am trying to search two vectors (each of any size) for elements that are identical and then delete both elements.
My implementation is as follows:
for (int i = vec1.size() - 1; i >= 0; i--) {
for (int j = 0; j < vec2.size(); j++) {
if (vec1[i] == vec2[j]) {
vec1.erase(vec1.begin() + i);
vec2.erase(vec2.begin() + j);
}
}
}
However, while this works for most cases, I am running into some where it doesn't. Is it the way I am iterating through these vectors or am I just going about this all wrong?

Answer 1

You don't actually need to iterate backwards at all. In which case your code can be:
for (int i = 0; i < vec1.size(); i++) {
for (int j = 0; j < vec2.size(); j++) {
if (vec1[i] == vec2[j]) {
vec1.erase(vec1.begin() + i);
vec2.erase(vec2.begin() + j);
}
}
}
But wait up...what happens after we erase an element? Then all of the elements after it have their indexes decreased by 1, so we'll skip the next item! To fix that we can add this small modification:
vec1.erase(vec1.begin() + i--);
vec2.erase(vec2.begin() + j--);
^^^^
This will work even when we change the size by erasing, because we're checking the size of the vec2 every loop! But what if we end up erasing the last item of vec1? We don't compare its size again until we've iterated all the way through vec2, which will be a problem in your vec1 = {2}, vec2 = {2, 2, 2} example. To fix that we can just break out of the inner loop and repeat the check on vec2.
Put it all together (and change your subscript operator into .at() calls so we'll have bounds checking) and you get:
for (int i = 0; i < vec1.size(); i++) {
for (int j = 0; j < vec2.size(); j++) {
if (vec1.at(i) == vec2.at(j)) {
vec1.erase(vec1.begin() + i--);
vec2.erase(vec2.begin() + j--);
break;
}
}
}
(See it in action here: ideone)

Answer 2

The problem is that you keep accessing vec1[i] as you loop over vec2 after deleting an element from vec1 and vec2. This causes undefined behavior if you do this after removing the last element in vec1 as vec1[i] is no longer valid. Add a break statement in your if to fix this.
for (int i = vec1.size() - 1; i >= 0; i--) {
for (int j = 0; j < vec2.size(); j++) {
if (vec1[i] == vec2[j]) {
vec1.erase(vec1.begin() + i);
vec2.erase(vec2.begin() + j);
break; // Look at next element in vec1
}
}
}
There's also a more efficient way of doing this too (O(n*log(n)+m*log(m)+n+m) instead of O(n*m) for n=vec1.size() and m=vec2.size()). It involves sorting the vectors. I'll leave that to you to figure out.

Answer 3

If you can sort, you could do something like this:
#include <algorithm>
#include <iostream>
#include <vector>
int main() {
std::vector<int> ex {3, 1, 2, 3, 3, 4, 5}, as {2, 3, 6, 1, 1, 1}, tmp;
std::sort(std::begin(ex), std::end(ex));
std::sort(std::begin(as), std::end(as));
as.erase(
std::remove_if(
std::begin(as),std::end(as),
[&](int const& s){
bool found = std::binary_search(std::begin(ex), std::end(ex), s);
if (found) {
tmp.push_back(s);
}
return found;}), std::end(as));
for (auto const& i : tmp) {
ex.erase(std::remove(std::begin(ex),std::end(ex), i), std::end(ex));
}
}

Answer 4

Try use std::set_difference to subtract one vector from another and them merge these subtractions with a help of std::merge. But vectors need to be sorted to use these functions, so use std::sort at first. Code is here:
void TraceVector( std::vector<int> v, const std::string& title )
{
if ( !title.empty() )
{
std::cout << title << std::endl;
}
std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, ","));
std::cout << std::endl;
}
int main() {
std::vector<int> Vec1 {7, 1, 2, 5, 5, 5, 8, 9};
std::vector<int> Vec2 {3, 2, 5, 7, 10};
std::vector<int> Difference1; // Contains subtraction Vec1 - Vec2
std::vector<int> Difference2;// Contains subtraction Vec2 - Vec1
std::vector<int> Merged; // RESULT Merged vector after subtractions
//Need to be sorted
std::sort(Vec1.begin(), Vec1.end());
std::sort(Vec2.begin(), Vec2.end());
TraceVector(Vec1, "Vec1 sorted is: ");
TraceVector(Vec2, "Vec2 sorted is: ");
//Make subtractions
std::set_difference(Vec1.begin(), Vec1.end(), Vec2.begin(), Vec2.end(),
std::inserter(Difference1, Difference1.begin()));
std::set_difference(Vec2.begin(), Vec2.end(), Vec1.begin(), Vec1.end(),
std::inserter(Difference2, Difference2.begin()));
TraceVector(Difference1, "Difference is: ");
TraceVector(Difference2, "Difference is: ");
//Merge subtrctions
std::merge(Difference1.begin(), Difference1.end(), Difference2.begin(), Difference2.end(), back_inserter(Merged));
TraceVector(Merged, "Merged is: ");
}
Output is:
Vec1 sorted is:
1,2,5,5,5,7,8,9,
Vec2 sorted is:
2,3,5,7,10,
Difference is:
1,5,5,8,9,
Difference is:
3,10,
Merged is:
1,3,5,5,8,9,10,
Program ended with exit code: 0