数据结构链表习题2.27，假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合,现要求另辟空间构成一个顺序链表

方法：不太好表达，总之先保证a表中的指针不越界，然后依次和b表中的元素比较，如果b表中一个与之相等的元素都没有，那么指针pa指向的值就要删掉，否则向前移动，继续比较a表中的下一个元素。
需要注意的是，每次比较，应该先保证pa指向的指针与前面的值不相同，否则应该删除，代码的注释写得很详细，很简洁，就不多废话了

#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#define SIZE 10
#define EXTERN 1
#define Elemtype int
#define Status
#define SUCCESS 1
#define FAIL 0

typedef struct SeqList
{
    Elemtype *base;
    int capacity;
    int size;
}List;

void initial(List *list);
void push_back(List *list,Elemtype x);
void show(List *list);
Status Extern(List *list);
void intersec(List *la,List *lb);

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

    printf("创建顺序表a(-1结束)\n");
    while(1)
    {
        scanf("%d",&x);
        if(x==-1)
            break;
        push_back(&la,x);
    }
    printf("这是顺序表a>>>");
    show(&la);

    printf("创建顺序表b(-1结束)\n");
    while(1)
    {
        scanf("%d",&x);
        if(x==-1)
            break;
        push_back(&lb,x);
    }
    printf("这是顺序表b>>>");
    show(&lb);

    printf("取得交集后的顺序表>>>");
    intersec(&la,&lb);
    show(&la);

    return(1);
}

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

    list->capacity=SIZE;//容量为10
    list->size=0;//表长为0
}

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

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

Status Extern(List *list)
{//本算法的前提是顺序表已经存在
    //本算法的功能是扩充顺序表的内存空间
    Elemtype *newbase;
    newbase=(Elemtype*)realloc(list->base,(list->capacity+EXTERN)*sizeof(Elemtype));

    if(newbase)//如果扩充成功
    {
        list->base=newbase;
        list->capacity+=EXTERN;
        return(SUCCESS);
    }
    else
    {
        return(FAIL);
    }
}

void intersec(List *la,List *lb)
{//本算法的前提是顺序表a和b中的元素按值递增
    //本算法的功能是求顺序表a和顺序表b的交集，并且交集C没有重复的元素
    //交集C存放到顺序表a中
    int pa=0,pb=0;//pa和pb分别指向顺序表la和lb中第一个元素

    while(pa<la->size)//表a还没有遍历完
    {
        if(pa==0 || pa!=0&&la->base[pa]!=la->base[pa-1])//如果不是pa指向第一个或者pa指向的元素和前面的不相同
        {
            while(pb<lb->size && lb->base[pb]<la->base[pa])
                pb++;
            if(pb<lb->size && lb->base[pb]==la->base[pa])//b中有和a中相同的元素，则保留a中这个元素
            {
                pa++;
            }
            else//如果没有，则这个元素多余
            {
                for(int i=pa;i<la->size-1;++i)
                    la->base[i]=la->base[i+1];
                la->size--;//表长减一
            }
        }
        else
        {
            for(int i=pa;i<la->size-1;++i)
                la->base[i]=la->base[i+1];
            la->size--;
        }
    }
}