链表去重

数据结构上机实验上的一道题。

设一带头结点的单链表，设计算法将表中值相同的元素仅保留一个结点。

 提示：指针p从链表的第一个元素开始，利用指针q从指针p位置开始向后搜索整个链表，删除与之值相同的元素；指针p继续指向下一个元素，开始下一轮的删除，直至p＝＝null为至，既完成了对整个链表元素的删除相同值。

解题思路：按照提示的意思就是一个双重循环的查找，像是暴力算法从母串中查找子串？我最开始就直接使用编写好的删除函数套在双重循环里面，这样做是可以的，但是时间复杂度有点高，O（n^3）!!!

#include<stdio.h>
#include<stdlib.h>
typedef struct Node
{
    int data;
    struct Node * next;
} Node,*LinkList;
int Delete(LinkList * L,int Location)
{
    LinkList q,p;
    int counts=0;
    int k=Location+1;
    q=(*L);
    p=(*L)->next;
    while(p->next)
    {
        q=q->next;
        p=p->next;
        counts++;
        if(counts==Location)
        {
            q->next=p->next;
        }
    }
    return 1;
}
int Unique(LinkList *L)
{
    LinkList p,q;
    int counts=1;
    int ans=0;
    p=(*L)->next;
    while(p)
    {
        q=p->next;
        counts=ans+1;;
        while(q)
        {
            if(p->data==q->data)
            {
                Delete(L,counts);
            }
            else
            {
                counts++;
            }
            q=q->next;
        }
        p=p->next;
        ans++;
    }
    return 1;
}
int Create(LinkList *L,int n)
{
    LinkList p,q;
    int Elem,i;
    q=(*L);
    printf("请按输入元素：
");
    for(i=0; i<n; i++)
    {
        p=(LinkList)malloc(sizeof(Node));
        scanf("%d",&Elem);
        p->data=Elem;
        q->next=p;
        q=p;
    }
    p->next=NULL;
    return 1;
}
int InitLinkList(LinkList * L)
{
    (*L)=(LinkList)malloc(sizeof(Node));
    if((*L)==NULL)
    {
        printf("ERROR
");
        return 0;
    }
    (*L)->next=NULL;
    return 1;
}
void Print(LinkList *L)
{
    LinkList p;
    p=(*L)->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("
");
}
int main()
{
    LinkList L;
    int Number;
    InitLinkList(&L);
    printf("请输入元素的个数：
");
    scanf("%d",&Number);
    Create(&L,Number);
    printf("原先的元素有
");
    Print(&L);
    Unique(&L);
    printf("去重后的元素有
");
    Print(&L);
    return 0;
}

更改后的去重背调函数：

int Unique(LinkList *L)
{
    LinkList p,q,k;
    q=p=(*L)->next;
    while(p->next)///查找和节点p重复的节点，重复则删除。
    {
        q=p;
        k=q->next;
        while(k)
        {
            if(k->data==p->data)///重复判断
            {
                q->next=k->next;///从链表里删除
                free(k); ///实际删除节点，释放内存
                k=q->next; ///保持k=q->next;
            }
            else
            {
                q=k;
                k=k->next;
            }
        }
        if(p->next)
        {
            p=p->next;
        }
    }
    return 1;
}

能够将时间复杂度将到O(n^2)