c++ Algorithm remove duplicates - both values - c++

Question

EDIT NOTE: This is not a code review, rephrased the question.
Discussion on algorithm implementation at: https://codereview.stackexchange.com/questions/80412/c-algorithm-remove-duplicates-both-values
My Special case:
Home Project, Automatic Downloader for Podcasts.
Overall Algorithm is:
Download a list of available podcasts
hash the podcasts
load metadata + hash of downloaded podcasts from sqlite db
Algorithm this questions is about - throw out all already downloaded.
Download new podcasts
save metadata to sqlite db
Note this algorithm works only to remove 2 duplicates, if there are more than 2 it breaks, please look at the overall algorithm.
Question: is there a name for this algorithm 4 or an aquivalent algorithm?
Question: are there different approaches than my example code below
As a discussion basis the code
Requirements: c++11 compiler e.g gcc 4.9
note: copy paste ready code.
#include <algorithm>
#include <vector>
#include <iostream>
#include <iterator>
#include <string>
template <typename ForwardItr>
ForwardItr doubleEraser(ForwardItr first, ForwardItr last)
{
auto itr = first;
typename std::iterator_traits<ForwardItr>::value_type firstMatch = *first;
bool hasFirstMatch(false);
while(itr != last)
{
auto next = std::next(itr);
if(next != last && *itr == *next)
{
if(!hasFirstMatch)
{
hasFirstMatch = true;
firstMatch = *itr;
}
else
{
if(*itr == firstMatch) // again at first match
{
return itr;
}
}
std::rotate(itr, std::next(itr, 2), last); // throw matched elements to the end of container
}
else
++itr;
}
return last;
}
template <typename T>
void print(T& c)
{
for(auto & element : c)
std::cout << element << " ";
std::cout << "\n";
}
template <class T>
void process(std::vector<T>& t)
{
std::string formating(" \t");
std::cout << "input: " << formating;
print(t);
std::sort(t.begin(), t.end());
std::cout << "sorted:" << formating;
print(t);
auto itr_begin = doubleEraser(t.begin(), t.end());
std::cout << "dEraser:" << formating;
print(t);
t.erase(itr_begin, t.end());
std::cout << "output:" << formating;
print(t);
}
int main()
{
std::vector<int> vec {1,2,3,4,5,6,7,8,9,3,5,6,7,2};
std::vector<char> vec2 {'A', 'C', 'D', 'D', 'G', 'A' };
std::vector<std::string> vec3 {"Hello", "World", "that", "be", "that", "Hello"};
process(vec);
process(vec2);
process(vec3);
}

Answer 1

A simple approach requiring more space complexity. Map unique values and their indexes in reverse order, then just sort by indexes form a helper vector. Similar can be done for string but requires specific compare function.
Edit: for more complete example.
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
template <typename T>
struct cmp
{
bool operator()(std::pair<T, int>& a,
std::pair<T, int> & b)
{
return a.second < b.second;
}
};
template <typename T, typename Predicate_T>
class RemoveDups
{
std::map<T, int> m_mapped;
std::vector<std::pair<T, int>> m_sorted;
public:
std::vector<T> operator()(const std::vector<T> in)
{
std::vector<T> ret;
ret.reserve(in.size());
for(int i=in.size()-1; i >= 0; i--)
m_mapped[in[i]] = i;
for(auto it : m_mapped)
m_sorted.push_back(it);
std::sort(m_sorted.begin(), m_sorted.end(), Predicate_T());
for (auto it : m_sorted)
ret.push_back(it.first);
return ret;
}
};
int main()
{
std::vector<int> v = {1,1, 2, 2, 7, 2, 2, 7, 7, 2, 3, 8, 4, 5, 3, 2, 3, 2, 6, 2, 3, 2, 9, 10, 1, 2, 2, 1};
std::vector<std::string> s = {"world", "hello", "there", "world", "man", "there", "john", "doe", "doe", "john"};
RemoveDups<int, cmp<int>> c;
v = c(v);
RemoveDups<std::string, cmp<std::string>> vs;
s = vs(s);
for(auto p : v)
std::cout << p<< " ";
std::cout << "\r\n";
for(auto ps : s)
std::cout << ps << " ";
std::cout << "\r\n";
return 0;
}

Answer 2

I think what you're describing (or certainly what you want) is std::unique . It removes all consecutive duplicates in the range (so more than just two duplicates like your algorithm). To work, std::unique requires that the input range is sorted and is implemented as follows:
template<class ForwardIt>
ForwardIt unique(ForwardIt first, ForwardIt last)
{
if (first == last)
return last;
ForwardIt result = first;
while (++first != last) {
if (!(*result == *first)) {
*(++result) = std::move(*first);
}
}
return ++result;
}