Переместить во второй список элементы, повторяющиеся в первом списке более одного раза

#include <iostream>
#include <algorithm>
#include <random>
 
struct ForwardListNodeBase {
    ForwardListNodeBase *next;
 
    ForwardListNodeBase() : next{this} {}
 
    ForwardListNodeBase(ForwardListNodeBase *after) : next(after->next) {
        after->next = this;
    }
 
    void remove(ForwardListNodeBase *previous) {
        previous->next = next;
    }
};
 
template<typename T>
struct ForwardListNode : public ForwardListNodeBase {
    T value;
 
    ForwardListNode(ForwardListNodeBase *after, const T &value) noexcept: ForwardListNodeBase{after}, value{value} {}
};
 
template<typename T>
struct ForwardListIterator {
    using Self = ForwardListIterator<T>;
    using Node = ForwardListNode<T>;
    using NodeBase = ForwardListNodeBase;
 
    using value_type = T;
    using pointer = value_type *;
    using reference = value_type &;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::forward_iterator_tag;
 
    NodeBase *node;
 
    ForwardListIterator(ForwardListNodeBase *node) noexcept: node{node} {}
 
    reference operator*() const noexcept {
        return static_cast<Node *>(node)->value;
    }
 
    reference operator->() const noexcept {
        return &static_cast<Node *>(node)->value;
    }
 
    Self &operator++() noexcept {
        node = node->next;
        return *this;
    }
 
    Self operator++(int) noexcept {
        Self result{node};
        node = node->next;
        return result;
    }
 
    friend bool operator==(const Self &a, const Self &b) noexcept {
        return a.node == b.node;
    }
 
    friend bool operator!=(const Self &a, const Self &b) noexcept {
        return a.node != b.node;
    }
};
 
template<typename T>
struct ForwardListConstIterator {
    using Self = ForwardListConstIterator<T>;
    using Node = const ForwardListNode<T>;
    using NodeBase = ForwardListNodeBase;
    using Iterator = ForwardListIterator<T>;
 
    using value_type = T;
    using pointer = const value_type *;
    using reference = const value_type &;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::forward_iterator_tag;
 
    const NodeBase *node;
 
    ForwardListConstIterator(const ForwardListNodeBase *node) noexcept: node{node} {}
 
    ForwardListConstIterator(const Iterator &i) noexcept: node{i.node} {}
 
    reference operator*() const noexcept {
        return static_cast<Node *>(node)->value;
    }
 
    reference operator->() const noexcept {
        return &static_cast<Node *>(node)->value;
    }
 
    Self &operator++() noexcept {
        node = node->next;
        return *this;
    }
 
    Self operator++(int) noexcept {
        Self result{node};
        node = node->next;
        return result;
    }
 
    friend bool operator==(const Self &a, const Self &b) noexcept {
        return a.node == b.node;
    }
 
    friend bool operator!=(const Self &a, const Self &b) noexcept {
        return a.node != b.node;
    }
};
 
template<typename Container>
struct ForwardListInsertIterator {
    using value_type = void;
    using reference = void;
    using const_reference = void;
    using pointer = void;
    using difference_type = void;
    using iterator_category = std::output_iterator_tag;
 
    using Self = ForwardListInsertIterator<Container>;
    using Iterator = typename Container::iterator;
 
    ForwardListInsertIterator(Container &container, Iterator position) noexcept
            : container{container}, position{position} {}
 
    Self &operator=(typename Container::const_reference value) {
        position = container.insert_after(position, value);
        return *this;
    }
 
    Self &operator*() {
        return *this;
    }
 
    Self &operator++() {
        return *this;
    }
 
    Self &operator++(int) {
        return *this;
    }
 
    Container &container;
    Iterator position;
};
 
template<typename T>
class ForwardList {
public:
    using Self = ForwardList<T>;
    using NodeBase = ForwardListNodeBase;
    using Node = ForwardListNode<T>;
 
    using value_type = T;
    using reference = value_type &;
    using const_reference = const value_type &;
    using pointer = value_type *;
    using const_pointer = const value_type *;
    using iterator = ForwardListIterator<T>;
    using const_iterator = ForwardListConstIterator<T>;
 
    ForwardList() noexcept: base{} {}
 
    ForwardList(const Self &) = delete;
 
    Self &operator=(const Self &) = delete;
 
    iterator before_begin() {
        return &base;
    }
 
    iterator begin() {
        return base.next;
    }
 
    iterator end() {
        return &base;
    }
 
    const_iterator before_begin() const {
        return &base;
    }
 
    const_iterator begin() const {
        return base.next;
    }
 
    const_iterator end() const {
        return &base;
    }
 
    iterator insert_after(const_iterator position, const_reference value) {
        return new Node{const_cast<NodeBase*>(position.node), value};
    }
 
    iterator erase_after(const_iterator position) {
        Node *node = position.node->next;
        node->remove(position.node);
        delete node;
        return position.node->next;
    }
 
    iterator push_front(const_reference value) {
        return insert_after(before_begin(), value);
    }
 
    void pop_front() {
        erase_after(before_begin());
    }
 
    bool isEmpty() const {
        return &base == base.next;
    }
 
    void clear() {
        while (!isEmpty()) {
            erase_after(before_begin());
        }
    }
 
private:
    NodeBase base;
};
 
template<typename T, typename Iterator>
bool contains(Iterator begin, Iterator end, const T &value) {
    for (; begin != end; ++begin) {
        if (*begin == value) {
            return true;
        }
    }
    return false;
}
 
template<typename T>
ForwardListInsertIterator<ForwardList<T>> inserter(ForwardList<T> &list, typename ForwardList<T>::iterator position) {
    return ForwardListInsertIterator<ForwardList<T>>(list, position);
}
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const ForwardList<T> &list) {
    out << "[";
    for (auto i = list.begin(); i != list.end();) {
        out << *i++;
        if (i != list.end()) {
            out << ", ";
        }
    }
    return out << "]";
}
 
int main() {
    std::random_device randomDevice;
    std::mt19937 randomGenerator(randomDevice());
    std::uniform_int_distribution<int> numbersDistribution{0, 10};
 
    ForwardList<int> a;
    auto back_inserter = inserter(a, a.before_begin());
    for (int i = 0; i < 10; ++i) {
        *back_inserter++ = numbersDistribution(randomGenerator);
    }
 
    std::cout << a << std::endl;
 
    ForwardList<int> b;
    auto b_inserter = inserter(b, b.before_begin());
    for (auto i = a.begin(); i != a.end(); ++i) {
        auto j = i;
        ++j;
        if (j == a.end()) {
            break;
        }
        if (contains(j, a.end(), *i) && !contains(b.begin(), b.end(), *i)) {
            *b_inserter++ = *i;
        }
    }
 
    std::cout << b << std::endl;
    return 0;
}