c++ 链表删除重复的数据

//List.h

#include <iostream>
typedef int dataType;

struct Node{
    Node():data(0),pNextNode(NULL){} //结点构造函数
    dataType data;
    Node* pNextNode;
};
class List{
private:
    Node *head; //作为链表唯一的头指针
    int size;   //链表长度
public:
    List(){head=new Node;size=0;}
    bool isEmpty();                //判断是否空表
    bool InsertList(int i,dataType elem);　　//i的指标从1开始，而不是从0开始
    void PushList(dataType elem);        　 //在链表尾部添加元素
    bool DeleteList(int i);        //删除指定位置的元素
    void ClearList();            //清除整条链表
    void DeleteRepetitiveData();//删除重复元素
    void PrintList();            //按顺序输出链表
    int GetSize();    
    Node* Fine(int i);            //找到第i个结点并返回该结点的指针
    Node* FinePre(int i);        //找到第i个结点前的结点，返回指针
};

//List.cpp

#include "List.h"
#include <iostream>
#include <vector>
using namespace std;
//判断空表
bool List::isEmpty(){
    if(head==NULL)
        return false;
    else
        return true;
}
//在第i位插入数据
bool List::InsertList(int i,dataType elem){
    if (i<1)
        return false;
    else if(head==NULL||i==1)//如果是空表
    {
        head->data=elem;
        size++;
        return true;
    }
    else if (i>size)        //位标大于链表长度时，在尾部添加
    {
        PushList(elem);
        return true;
    }
    else
    {
        Node *pre=Fine(i-1);
        Node *follow=Fine(i);
        Node *s=new Node;        //为新结点申请内存
        pre->pNextNode=s;        //连接前结点
        s->pNextNode=follow;    //连接后结点
        s->data=elem;
        size++;
        return true;
    }
}
//在尾部添加元素
void List::PushList(dataType elem){
    if(head==NULL)
    {
        head=new Node;
        head->data=elem;
        size++;
    }
    else
    {
        Node *cur=head;
        while(cur->pNextNode)
            cur=cur->pNextNode;
        Node *s=new Node;
        cur->pNextNode=s;
        s->data=elem;
        size++;
    }
}
//打印链表
void List::PrintList(){
    Node *cur=head;
    while (cur!=NULL)
    {
        cout<<cur->data<<"  ";
        cur=cur->pNextNode;
    }
    cout<<endl;
}
//size
int List::GetSize(){
    return size;
}
//找到第i个结点
Node* List::Fine(int i){
    if(i==1)
        return head;
    else
    {
        Node *cur=head;
        for (int pos=1;pos<i;pos++)
            cur=cur->pNextNode;
        return cur;
    }    
}
//找到i的前一个个结点
Node* List::FinePre(int i){
    if(i<2)
    {
        cout<<"参数必须大于等于2！"<<endl;
        return NULL;
    }
    else if(i==2)
        return head;
    else
        return Fine(i-1);
}
//删除第i个元素
bool List::DeleteList(int i){
    if (i<1||i>size)        //限制i的范围
        return false;
    else if(i==1)
    {
        Node *temp=head;
        head=head->pNextNode;
        delete temp;
        size--;
        return true;
    }
    else
    {
        Node *cur=this->Fine(i);
        Node *pre=this->FinePre(i);
        pre->pNextNode=cur->pNextNode; //重新连接结点
        delete cur;
        size--;
        return true;
    }
}
//清空整个链表
void List::ClearList(){
    Node *temp=head;
    while (head!=NULL)
    {
        temp=head;
        head=head->pNextNode;
        delete temp;
    }
    size=0;
}
//删除重复元素
void List::DeleteRepetitiveData(){
    int flag=0;        //代码运行标志,0为未运行
    if(size==1)        //只有一个元素时跳出
        return;
    Node *stand=head;//内循环结束后或者找到相同数据后才会指向下个结点
    Node *cursor;    //游标
    vector<int>storge;
    for (int i=0;i<size;i++)
    {            //用for循环是因为要得到被删除元素的位置
                //采用握手式比较，算法的时间复杂度为O(n^2)
        cursor=stand->pNextNode;
        flag=0;
        while(cursor!=NULL)
        {
            if(stand->data==cursor->data)
            {
                stand=stand->pNextNode;
                flag=1;
                //将重复的数据的下标降序保存起来
                storge.insert(storge.begin(),i+1);
                break;
            }
            else
                cursor=cursor->pNextNode;
        }    
        if(!flag)
            stand=stand->pNextNode;
    }
    int itemp=storge.size();
    while (itemp--)        
    {
        this->DeleteList(storge.at(0));//提取下标，释放多余结点
        storge.erase(storge.begin());
    }
    storge.clear();　　　　//释放vector内存
}

//main.cpp

#include "List.h"
#include <iostream>
using namespace std;

void main(){
    //List类测试代码
    List list;
    list.InsertList(1,1);
    list.InsertList(5,3);
    list.InsertList(2,2);
    list.InsertList(4,4);    
    list.PrintList();        //打印这4个元素
    cout<<"链表的长度为："<<list.GetSize()<<endl;
    cout<<"现在删除第2个元素"<<endl;
    list.DeleteList(2);        
    list.PrintList();        
    cout<<"现在清空链表"<<endl;
    list.ClearList();        //清空链表
    cout<<"输出空表："<<endl;
    list.PrintList();        
    
    list.PushList(4);
    list.PushList(1);
    list.PushList(7);
    list.PushList(1);
    list.PushList(1);
    list.PushList(2);
    list.PushList(2);        //压入4 1 7 1 1 2 2
    cout<<"输出链表新加入的元素："<<endl;    
    list.PrintList();
    cout<<"删除相同元素后的链表为："<<endl;    
    list.DeleteRepetitiveData();
    list.PrintList();
}

/*
总结：
1.链表类应该先写Fine()和FindPre()，再写插入和删除
2.链表的结构应该给每一个结点加上一个下标。因为下标在
  操作时再加上的话，元素跟下标是不统一的，
  如果有元素被删除，下标将要重新分配。
　这就导致void List::DeleteRepetitiveData()不能用
　相对直接的方法在检测到重复数据时就删除数据，而要借助vector
  间接删除

*/