Реализовать удаление повторений из списка

//Дана последовательность целых чисел. Сформировать линейный список. Преобразовать список удалив из него повторяющиеся ровно два раза числа.
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
struct node {int inf; node* ref;};
node * genesis(int); // Функция создания (Генезис - книга бытия)
void kill (node *); // Уничтожение частей списка
bool twice (node *, node *); // счетчик. 1 если 2 одинаковых элемента. 0 в иных случаях
int only (node *, int); // для создания уникального заглавного элемента (конец списка)
void main()
{
    node *beg,*work,*helper;
    int N,m;
    bool del;
    beg = new node;
    cout<<"Input the number of nodes";
    cin>>N;
    beg=genesis(N); // задаем список из N элементов
    helper=new node;
    helper->inf=N; // (1)
    helper->ref=beg; // (2)
    beg=helper; // (1), (2) и данная строки - задание головного (начального) элемента списка
    m=only(beg,N);
    for(work=beg->ref;work->ref;work=work->ref);
    work->ref=new node; //(1)
    work->ref->inf=m; // (2)
    work->ref->ref=NULL; // (3) -  создание заглавного элемента в конце списка.
    work=beg->ref;
    while(work->ref) // цикл проверки элементов
    {
        del=true;
        if(twice(work,beg)) // если два одинаковых то начаинаем прокрутку в поисках еще одного, окромя p элемента
        {
            for(helper=work->ref;helper&&del;helper=helper->ref)
                if(work->inf==helper->inf)
                {
                    kill(helper); // удаление второго из двух элементов
                    del = false; // как только нашли - выходим
                    
                }
                kill(work); // удаление первого из двух элементов
                // так как происходит сдвиг (из-за ф-ции kill), то сдвигать больше не надо
        }
        else
            work=work->ref; // если элементов не 2 - сдвиг
    }
    
    cout<<"After killing pairs will remain these elements: "<<'\n';
    if(beg->ref->inf==m)
        cout<<"All elements killed!"<<'\n';
        else
        for(work=beg->ref;work->ref;work=work->ref)
            cout<<work->inf<<" ";
        
}
node * genesis(int n)
{
    node *p,*c;
    int i=0;
    c=new node;
    cin>>c->inf;
    p=c;
    int x;
    while(i<n-1)
    {
        cin>>x;
        p->ref=new node;
        p=p->ref;
        p->inf=x;
        i++;
    }
    p->ref=NULL;
    return c;
    
}
void kill (node *c)
{
    if(c->ref==NULL)
    { delete c;
    c=NULL;
    }
    else
    {
        node *q;
        q=c->ref;
        *c=*q;
        delete q;
    }
    
}
bool twice (node *c,node *b) // счетчик элементов
{
    bool twicer=false;
    int i,x;
    node *k;
    b=b->ref;
    k=new node;
    i=0;
    x=c->inf;
    for(k=b;k;k=k->ref)
        if(k->inf==x)
            i++;
        if(i==2)
            twicer=true;
        return twicer;
}
int only (node *c, int t)
{
    int k,i;
    node *p;
    k=c->inf;
    for(i=0;i<t;i++)
    {
        for(p=c;p;p=p->ref)
            if(k==p->inf)
                k++;
    }
    return k;
}

#include <iostream>
 
struct Node {
    int data = 0;
    Node* next = nullptr;
};
 
struct List {
    Node* head = nullptr;
    Node* last = nullptr;
    size_t count = 0;
};
 
void push_back(List& l, int data) {
    Node *tmp = new Node;
    tmp->data = data;
    tmp->next = nullptr;
 
    if (!l.head) l.head = tmp;
    if (l.last) l.last->next = tmp;
    l.last = tmp;
    l.count++;
}
 
void push_front(List& l, int data) {
    Node *tmp = new Node;
    tmp->data = data;
    tmp->next = l.head;
 
    if (!l.last) l.last = tmp;
    l.head = tmp;
    l.count++;
}
 
void destroy(List& l) {
    while (l.head) {
        l.last = l.head;
        l.head = l.head->next;
        delete l.last;
    }
    l.head = l.last = nullptr;
    l.count = 0;
}
 
void print(const List& l) {
    Node *tmp = l.head;
    while (tmp) {
        std::cout << tmp->data << " -> ";
        tmp = tmp->next;
    }
    std::cout << "nullPtr";
}
 
void removeNode(List &l, Node *remove_node) {
    Node*tmp = l.head;
    while (tmp->next != remove_node)
        tmp = tmp->next;
    tmp->next = remove_node->next;
    delete remove_node;
    l.count--;
}
 
void removeRepeats(List &l) {
    Node *tmp1, *tmp2;
    tmp1 = l.head;
    while (tmp1) {
        tmp2 = tmp1->next;
        while (tmp2){
            if (tmp2->data == tmp1->data) {
                removeNode(l, tmp2);
                tmp2 = tmp1;
            }
            tmp2 = tmp2->next;
        }
        tmp1 = tmp1->next;
    }
}
 
int main(){
    List l;
    for (int i = 0; i < 10; i++) {
        push_back(l, i);
    }
    for (int i = 0; i < 10; i += 3) {
        push_back(l, i);
    }
    print(l);
    removeRepeats(l);
    std::cout << std::endl;
    print(l);
    destroy(l);
    std::cout << std::endl;
    system("pause");
    return 0;
 
}