这个是顺序表的，单链表我也有写，在另一个文章
不善于解释，代码在下面，function函数是主要实现的函数，时间复杂度为O(n)，希望能帮到你

#include<malloc.h>
#include<assert.h>
#include<stdio.h>
#define SUCCESS 1
#define FAIL 0
#define Elemtype int
#define SIZE 10
#define EXTERN 1
#define Status int
typedef struct SeqList
{
    Elemtype *base;
    int capacity;
    int size;
}List;

Status extern_(List *list);
void initial(List *list);
void push_back(List *list,Elemtype x);
void show(List *list);
void function(List *la,List *lb,List *lc);

int main()
{
    List la,lb,lc;
    initial(&la);
    initial(&lb);
    initial(&lc);

    printf("构造顺序表a（要显示的链表）(-1 end)\n");
    int x;
    while(1)
    {
        scanf("%d",&x);
        if(x==-1)
            break;
        push_back(&la,x);
    }
    printf("这是顺序表a>>>");
    show(&la);

    printf("构造顺序表b（要显示的链表）(-1 end)\n");
    while(1)
    {
        scanf("%d",&x);
        if(x==-1)
            break;
        push_back(&lb,x);
    }
    printf("这是顺序表b>>>");
    show(&lb);

    printf("构造顺序表c（要显示的链表）(-1 end)\n");
    while(1)
    {
        scanf("%d",&x);
        if(x==-1)
            break;
        push_back(&lc,x);
    }
    printf("这是顺序表c>>>");
    show(&lc);

    function(&la,&lb,&lc);
    printf("function后的顺序表a>>>");
    show(&la);

    return(1);
}

void initial(List *list)
{//本算法的功能是初始化顺序表list
    //为顺序表初始化大小为十个空间的内存
    list->base=(Elemtype*)malloc(SIZE*sizeof(Elemtype));
    assert(list->base!=NULL);

    list->size=0;
    list->capacity=SIZE;
}

void push_back(List *list ,Elemtype x)
{//本算法的前提是顺序表已经初始化并且内存空间未满
    //本算法的功能是在顺序表的尾部插入数据元素x
    if(list->size==list->capacity&&!extern_(list))
        return;//空间已满

    list->base[list->size]=x;
    list->size++;//表长加一
}

void show(List *list)
{//本算法的前提是顺序表已经初始化并且顺序表至少有一个元素
    //本算法的功能是依次显示顺序表中的元素
    int i;
    if(list->size==0)
        return;//表长合法性判断

    for(i=0;i<list->size;++i)
        printf("%d ",list->base[i]);
    printf("\n");
}

Status extern_(List *list)
{//本算法的前提是顺序表已经初始化
    //本算法的功能是增加顺序表的长度，一次增大的长度为EXTERN
    Elemtype *newbase;
    newbase=(Elemtype*)realloc(list->base,(list->capacity+EXTERN)*sizeof(Elemtype));
    assert(newbase!=NULL);

    if(newbase!=NULL)//分配成功
    {
        list->base=newbase;
        list->capacity+=EXTERN;
        return(SUCCESS);
    }
    else
    {
        return(FAIL);
    }
}

void function(List *la,List *lb,List *lc)
{//本算法的前提是la,lb,lc中都至少有一个元素
    //本算法的功能是去掉la中在lb和lc同时出现的元素
    if(la->size==0 || lb->size==0 || lc->size==0)
        return;//表长合法性判断

    int pa,pb,pc,i;
    pa=0;
    pb=0;
    pc=0;//三个指针分别指向顺序表的第一个元素

    while(pa<la->size && pb<lb->size && pc<lc->size)//三个指针都没有越界
    {
        while(pb<lb->size && pc<lc->size && lb->base[pb]!=lc->base[pc])//指针指向的值小的往前移，直到相等
        {
            if(lb->base[pb]<lc->base[pc])
                pb++;
            else
                pc++;
        }
        if(pb<lb->size && pc<lc->size)//pb和pc指向表中值相同的元素
        {
            while(pb!=lb->size-1&&lb->base[pb]==lb->base[pb+1] || lc!=lc->size-1&&lc->base[pc]==lc->base[pc+1])//让pb和pc中分别指向重复出现的元素中的最后一个
            {
                if(lb->base[pb]==lb->base[pb+1]) //如果这个元素直接后继相同，就指向这个直接后继
                    pb++;
                if(lc->base[pc]==lc->base[pc+1])
                    pc++;
            }
            while(pa<la->size && la->base[pa]<lb->base[pb]) 
                pa++;
            if(pa<la->size && la->base[pa]==lb->base[pb])//如果在A中找到这个在B和C中重复出现的元素
            {
                for(i=pa;i<la->size-1;++i)
                    la->base[i]=la->base[i+1];//给予删除
                la->size--;//表长减一
            }
            else//如果A中不存在这个元素
            {
                pb++;
                pc++;
            }//pb和pc都同时后移
        }
    }
}