Оставить в списке L только первые вхождения одинаковых элементов

#include <iostream>
#include <algorithm>
 
template <typename T>
struct Node
// узел или нода. Список это сеть узлов, по которому мы гуляем, когда работаем с ним
// Список это не один массив данных. Это именно порядок узлов, где они друг на друга ссылаются
{
    // Здесь хранится передаваемая переменная
    T data;
    // Указатель на следующий элемент
    Node* next;
};
 
template <typename T>
class List
{
private:
    // Указатель на первый элемент
    Node<T>* head;
    // Размер лист
    int size;
    int lst;
public:
    List() {
        // head - указатель на первый элемент
        // У нас список с односвязным связыванием.
        head = nullptr;
        size = 0;
        lst=0;
    };
    T& operator[](const int index)
    {
        int count = 0;
        Node<T>* current = head;
        while (current != nullptr)
        {
            if (count == index)
                return current->data;
            current = current->next;
            count++;
        }
    }
    /* удаляет повторяющиеся элементы списка */
    void remove_duplicates(int n) 
    {
        Node<T> *pr;
        Node<T> *p=head;
        Node<T> *td;
        int k=0;
        while (p!=NULL)
        {
            if (p==p->next)
            {
                for(int i=1;i<n && p->next!=NULL;i++)
                {
                    p=p->next;
                
                    pr=head;
                    while(pr->next!=p)
                    {
                        pr=pr->next;
                    }
                    pr->next=p->next;
                    delete(p);
                }
            }
            else
            p=p->next;
        }
    }
    
    void add(T value)
    {
        if (head == nullptr)
        {
            head = new Node<T>;
            head->data = value;
            head->next = nullptr;
        }
        else
        {
            Node<T>* tmp = new Node<T>;
            tmp->data = value;
            tmp->next = nullptr;
            Node<T>* current = head;
            while (current->next != nullptr)
            {
                current = current->next;
            }
            current->next = tmp;
        }
        size++;
    }
 
    void print_data() 
    {
        // вывод всего списка
        Node<T>* current = head;
        // пока у текущего элемента есть следующий
        while (current->next) {
            // выводим его на экран
            std::cout << current->data << " ";      
            // текущий = следующий
            current = current->next;
        }
        std::cout << current->data << " ";
        std::cout << std::endl;
    }
};
 
    int main()
    {
    int count;
    int n;
    List<int> list;
    //List<long> lst=NULL;
    std::cout<<"Number of elements: ";
    std::cin >> n;
    for (int i=0; i<n; i++) {
        std::cout << "Input List[" << i << "]=";
        std::cin >> count;
        list.add(count);
    };
    std::cout<<("With duplicates:\n");
    list.print_data();
    list.remove_duplicates(n);
    std::cout<<"Without duplicates:\n";
    list.print_data();
    return 0;
}

if (p == p->next)