线性表顺序实现

线性表实现，创建表，插入元素，删除元素，销毁表，表的遍历，表的并集交集差集。。。。。不断更新中。。。

#include<iostream>
#include<cstdio>
#include<stdlib.h>
#include<string.h>
#define LIST_INIT_SIZE 100//初始大小
#define error 0
#define LISTINCREMENT 10//增量大小
#define OK 0

typedef int ElemType;
typedef int Status;

using namespace std;

int vis[1000];

typedef struct
{
    ElemType *elem;
    int length;
    int listsize;
} SqList;

Status InitList(SqList &L)//创线性表
{
    L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));//申请空间并返回首地址
    if(!L.elem)//申请失败退出
    {
        exit(0);
    }
    L.length=0;
    L.listsize=LIST_INIT_SIZE;
    cout<<"新表创建完成"<<endl;
    return OK;
}

Status Destroy(SqList &L)//销毁线性表
{
    free(L.elem);//释放空间
    L.length=0;
    L.elem=NULL;
    L.listsize=0;
    return OK;
}

Status ListInsert(SqList &L,int i,ElemType e)//插入数据
{
    ElemType *newbase,*p,*q;
    if(i<1||i>L.length+1)//插入位置不对退出
    {
        return error;
    }
    if(L.length>=L.listsize+1)
    {
        newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));//扩容重新分配基址
        if(!newbase)//分配失败退出
        {
            exit(0);
        }
        L.elem=newbase;//新的基址
        L.listsize+=LISTINCREMENT;
    }
    q=&(L.elem[i-1]);//q是是插入位置
    for(p=&(L.elem[L.length-1]); p>=q; --p)
    {
        *(p+1)=*p;//插入位置之后的元素向后移动
    }
    *q=e;//插入到*q所指向的位置
    ++L.length;
    return OK;
}

Status ListDelete(SqList &L,int i,ElemType &e)//删除元素
{
    ElemType *p,*q;
    if(i<i||i>L.length)//位置不合法
    {
        return error;
    }
    p=&(L.elem[i-1]);//p是被删除元素的位置
    e=*p;//被删除的元素赋值给e
    q=L.elem+L.length-1;//表尾元素的位置
    for(++p; p<=q; ++p)
    {
        *(p-1)=*p;//删除位置之后的元素向前移
    }
    L.length--;
    return OK;
}

void ListUnite(SqList La,SqList Lb,SqList &Lc)//线性表合并
{
    ElemType *pa,*pb,*pc;
    pa=La.elem;//La开头
    pb=Lb.elem;//Lb开头
    Lc.listsize=La.listsize+Lb.listsize;//新链表长度
    pc=(ElemType *)malloc(Lc.listsize*sizeof(ElemType));
    if(!Lc.elem)//申请失败
    {
        exit(0);
    }
    while(pa<=(La.elem+La.length-1)&&pb<=(Lb.elem+Lb.length-1))//开始有序合并
    {
        if(*pa<*pb)
        {
            *pc++=*pa++;
        }
        else
        {
            *pc++=*pb++;
        }
    }
    while(pa<=La.elem+La.length-1)//插入La剩余元素
    {
        *pc++=*pa++;
    }
    while(pb<=Lb.elem+Lb.length-1)//插入Lb剩余元素
    {
        *pc++=*pb++;
    }
}

void ReadList(SqList L)//遍历线性表
{
    cout<<"内容：";
    for(int i=0; i<L.length; i++)
    {
        cout<<L.elem[i]<<" ";
    }
    cout<<endl;
}

void BingJi(SqList l,SqList k,SqList &Result)//求l,k的并集存入Result
{
    /**线性表此时存储的是整型数据
    不妨设数组，初始化为0，表中出现过的数字x当作下标，则vis[x]=1,否则仍然为0，下次再遇到这个数字不作处理
    创建新的表，遍历数组vis，非0的插入新表Result
    **/
    memset(vis,0,sizeof(vis));
    ElemType *pl=l.elem+l.listsize-1,*pk=k.elem+k.listsize-1,*pa=l.elem,*pb=k.elem;
    //pa是l开头，pl是l末尾，pb是k开头，pk是k末尾
    int maxn=-1;//记录两个表的最大值，也是最后遍历vis的最大下标

    for(int i=0; i<l.length; i++)
    {
        if(0==vis[l.elem[i]])//为0说明之前没遇到过这个数字
        {
            vis[l.elem[i]]=1;
        }
        if(l.elem[i]>maxn)
        {
            maxn=l.elem[i];
        }
    }
    for(int i=0; i<k.length; i++)
    {
        if(0==vis[k.elem[i]])//功能同上
        {
            vis[k.elem[i]]=1;
        }
        if(k.elem[i]>maxn)
        {
            maxn=k.elem[i];
        }
    }

    for(int i=0, j=1; i<=maxn+1; i++)//将vis为1的全部插入到新的表中，访问下标终点是maxn
    {
        if(vis[i]==1)
        {
            ListInsert(Result,j,i);
        }
    }
}

void Jiaoji(SqList l,SqList k,SqList &Result)求l,k的交集存入Result
{
    /**线性表此时存储的是整型数据，
    不妨设数组，初始化为0，表中出现过的数字x当作下标，vis[x]++，最终重复出现的vis[i]值是2
    创建新的表，遍历数组vis，非0的插入新表Result
    **/
    memset(vis,0,sizeof(vis));
    ElemType *pl=l.elem+l.listsize-1,*pk=k.elem+k.listsize-1,*pa=l.elem,*pb=k.elem;
    //pa是l开头，pl是l末尾，pb是k开头，pk是k末尾
    int maxn=-1;//记录两个表的最大值，也是最后遍历vis的最大下标

    for(int i=0; i<l.length; i++)//l元素作下标
    {
        vis[l.elem[i]]++;
        if(l.elem[i]>maxn)
        {
            maxn=l.elem[i];
        }
    }
    for(int i=0; i<k.length; i++)//k元素作下标
    {
        vis[k.elem[i]]++;
        if(k.elem[i]>maxn)
        {
            maxn=k.elem[i];
        }
    }

    for(int i=0, j=1; i<=maxn; i++)//将vis为2的全部插入到新的表中，访问下标终点是maxn
    {
        if(vis[i]==2)
        {
            ListInsert(Result,j,i);
        }
    }
}

void l_k_ChaJi(SqList l,SqList k,SqList &Result)//求集合l-k的结果存入Result
{
    /**线性表此时存储的是整型数据，
    不妨设数组，初始化为0，表中出现过的数字x当作下标，l中的元素作下标时vis[i]+=2,k中的元素作下标时vis[i]+=3
    最终值为2的vis的下标是l-k的结果
    创建新的表，遍历数组vis，非0的插入新表Result
    **/
    memset(vis,0,sizeof(vis));
    ElemType *pl=l.elem+l.listsize-1,*pk=k.elem+k.listsize-1,*pa=l.elem,*pb=k.elem;
    //pa是l开头，pl是l末尾，pb是k开头，pk是k末尾
    int maxn=-1;//记录两个表的最大值，也是最后遍历vis的最大下标

    for(int i=0; i<l.length; i++)//l元素作下标
    {
        vis[l.elem[i]]+=2;
        if(l.elem[i]>maxn)
        {
            maxn=l.elem[i];
        }
    }
    for(int i=0; i<k.length; i++)//k元素作下标
    {
        vis[k.elem[i]]+=3;
        if(k.elem[i]>maxn)
        {
            maxn=k.elem[i];
        }
    }

    for(int i=0, j=1; i<=maxn; i++)//将vis为2的全部插入到新的表中，其他的不管，访问下标终点是maxn
    {
        if(vis[i]==2)
        {
            ListInsert(Result,j,i);
        }
    }
}

int main()
{
    SqList l,k;
    InitList(l);
    InitList(k);
    int n,m;

    cout<<"线性表L输入插入个数:";
    cin>>n;
    for(int i=0; i<n; i++)
    {
        int e;
        cin>>e;
        ListInsert(l,i+1,e);
    }
    cout<<"插入完成"<<endl;

    cout<<"线性表K输入插入个数:";
    cin>>m;
    for(int i=0; i<m; i++)
    {
        int e;
        cin>>e;
        ListInsert(k,i+1,e);
    }
    cout<<"插入完成"<<endl;

    SqList result;
    InitList(result);
    l_k_ChaJi(l,k,result);
    ReadList(result);

    system("pause");
    return 0;
}