线性表（思想+伪代码+部分代码实现）

a.  线性表（List）:零个或多个数据元素的有序序列。
b.  线性表的长度n=LIstLenght(L);当n=0时，线性表为空，即空表。
c.  在复杂的线性表中，一个数据元素可以是若干个数据项目组成。

1.线性表的抽象数据类型

 ADT 线性表 (List)
Data

Operation
    Initlist   (*L )       初始化建立一个空链表L
    ListEmpty  ( L )       若线性表为空 返回ture  否则，返回flash
    ClearList  (*L )       将线性表清空
    GetElem    (L,i,*e)    将线性表的第i个元素返还给e
    LocateElem (L,e)       在线性表中查找与给定e相同的元素  如果成功返还成功
    ListInsert (*L,i,e)    在线性表第i个位置插入元素e
    ListDelete (*L,i,*e)   删除线性表第i个位置元素，并用e作为返回值
    ListLength (L)         返回线性表的元素个数
endDT

 
2. 假设La表示集合A,Lb表示集合B       代码实现以下功能  ： 将所有的在线性表Lb但不在La的元素插入La中

void unionL(list *La,list Lb)
{
    int La_len,Lb_len,i;
    ElemType e;        //声明和La,Lb长度一样的元素e
    La_len=strlen(*La);
    Lb_len=strlen(Lb);
    for(i=1;i<=Lb_len;i++)
    {
        GetElem(Lb,i,&e);  //取Lb中第i个数据元素赋给e
        if(!LocateElem(*La,e)) //*La中不存在与e相同的元素
            ListTnstrt(La,++La,e); //插入
    }
}

3.线性表的顺序储存结构

线性表的顺序储存结构指的是用一段地址的存储单元依次存储线性表的数据元素

/*线性表的顺序储存结构*/

#define MAXSIZE 20     //储存空间初始分配量
typedef int ElemType;   //ELemType 类型根据实际情况而定，这里假设为int
typedef struct
{
    ElemType data[MAXSIZE]；//数组存储数据元素，最大值为MAXZIZE
    int lenght;   //线性表的长度
}SqList;

4.线性表的插入与删除操作

我们在这里提前规定，下文不在详细叙述

#define OK 1
#define EEEOR  0
#define TUER 1
#define FALSE 0

代码实现 : 用e返回L中第i个元素的值  (i如果在下标范围  返回数组在该处的值   否则  返回  0 )

<strong><span style="font-size:14px;">/*定义初始状态：顺序链表L已存在   1<=i<=ListLength(L)*/
/*操作结果：用e返回L中第i个元素的值*/
ststue GetElem(SqList L,int i,ElemType *e)
{
    if(L.lenght==0||i<1||i>L.lenght)
        return ERROR;//这里ERROR=0
    *e=L.data[i-1];
    return OK; //这里OK=1
}</span></strong>

单链表实现查找

<strong><span style="font-size:14px;">Ststue GetElem(LinkList L,int i,ElemType *e)
{
    int j;
    LinkList p;    //声明移指针p
    p=L->next;     //让p指向链表L的第一个结点
    j=i;           //记录
    while(p&&j<i)  //p不为空j!=0
    {
        p=p->next;  //让p指向下一个结点
        ++j;
    }
    if(!p||j>i)      //第i个结点不存在
        return ERROR;
    *e=p->data;    //读取第i个结点的数据
    return ok;
}</span></strong>

静态链表实现：

<strong><span style="font-size:14px;">int Malloc_SLL(staticLinkList space)
{
    int i=space[0].cur;//当前数组第一个元素cur储存的值；即准备返回的第一个备用空间的下标
    
    if(space[0].cur)  //由于要拿出来一个分量来使用，所以我们把他的下一个分量来备用
        space[0].cur=space[i].cur;
    return i;
}</span></strong>

在线性表的第i个位置插入新元素e，L长度加一

伪代码：

<strong><span style="font-size:14px;">Status ListInsert(SqList *L,int i,ElemType e)
{
   int k;
   if(L->lenght==MAXSIZE)   //顺序线性标已经满了
        return ERROR;
   if(i<1||i>L->lengght+1)   //当i不在范围内时
        return ERROR;       //返回 0
   if(i<=L->lenght)       //若插入数据位置不在表尾
   {
       for(k=L->lenght-1;k>=i-1;k--)  //将要插入位置的数据向后移动一位
       L->data[k+1]=L->data[k];
   }
   L->data[i-1]=e;   //插入新元素
   L->lenght++;
   return ok;
   }

}</span></strong>

单链表代码实现：

<strong><span style="font-size:14px;">Statue ListInsert(LinkList *L,int i,ElemType e)
{
    int j;
    LinkList p,s;
    p=*L;
    j=1;
    while(p&&j<i)  //寻找第i-1个结点
    {
        p=p->next;
        ++j;
    }
    if(!p||j<i)
        return ERROR;  //第i个结点不存在
    s=(LinkList)malloc(sizeof(Node));  //生成新节点(c标准函数)
    s->data=e;
    s->next=p->next; //将p的后继结点赋值给s的后继
    p->next=s;    //将s赋值给p的后继
    return ok;
}</span></strong>

静态链表实现：

<strong><span style="font-size:14px;">status ListInsert(StaticLinkList L,int i,ElemType e)
{
    int j,k,l;
    k=MAX_SIZE-1;  //注意k首先是最后一个元素的下标
    if(i<1||i>ListLength(L)+1)
        return ERROR;
    j=Malloc_SSL(L);   //获得空间分量的下标
    if(j)
    {
        L[j].data=e;   //将数据赋值给此分量的data
        for(l=1;l<=i-1;l++)  //找到第i个元素之前的位置
        k=L[k].cur;
        L[j].cur=L[k].cur;  //把第i个元素之前的cur赋值给新元素的cur
        L[k].cur=j;  //把新元素的下标赋值给第i个元素之前元素的cur
        return ok;
    }
    return ERRIR;
}</span></strong>

在线性表的第i个位置删除新元素e，L长度减一

伪代码：

<span style="font-size:14px;">Status LIstDelete(SqList *L,int i,ElemType *e)
{
    int k;
    if(L->lenght==0)      //当线性表为空
        return ERROR;
    if(i<1||i>L->lenght)     //删除位置不对
        return ERROE;
    *e=L->data[i-1];
    if(i<L->lenght)    //删除位置不是最后
    {
        for(k=i;k<L->lenght;k++)    //将删除位置后继元素前移
            L->data[k-1]=L->data[k];
    }
    L->lenght--;
    return ok;
}</span>

单链表代码实现：

<span style="font-size:14px;">Status ListDelete(LinkList *L,int i,ElemType *e)
{
    int j;
    LinkList p,q;
    p=*L;
    j=1;
    while(p->next&&j<i)  //遍历寻找第i-1个结点
    {
        p=p->next;
        ++j;
    }
    if(!(p->naxt)||j>i)
        return ERROR;   //将第i个结点不存在
        q=p->next;
        p->next=q->next;  //将q的后继赋值给p的后继
        *e=q->data;      //将q结点中的数据给e
        free(q);      //让系统回收此结点，释放结点
        return ok;
}</span>

5.单链表的整表创建

头插法

<span style="font-size:14px;">/*随机产生n个元素的值，建立带表头结点的单链线性表L(头插法)*/
void  CreateListHead(LinkList *L,int n)
{
    LinkLIst p;
    int i;
    srand(time(0));//初始化随机数字种子
    *L=(Linklist)malloc(sizeof(Node));
    (*L)->next=NULL;//先创建一个带头结点的单链表
    for(i=0;i<n;i++)
    {
        p=(LinkList)malloc(sizeof(Node));//生成新结点
        p->data=rand()%100+1;   //随机生成100以内的数字
        p->next=(*L)->next;
        (*L)->next=p;    //插入到表头
    }
}</span>

尾插法

<span style="font-size:14px;">void CreateListTail(LinkList *t,int n)
{
    LinkList p,r;
    int i;
    srand(time(0));//初始化随机数种子
    *L=(LinkList)malloc(sizeof(Node));//为整个线性表
    r=*L;  //r为指向尾部的结点
    for(i=0;i<n;i++)
    {
        p=(Node *)malloc(sizeof(Node));//生成新结点
        p->data=rand()%100+1;//随机生成100以内的数字
        r->next=p;//将表尾终端结点的指针指向新结点
        r=p;//将当前的新结点定义为表尾终端结点
    }
    r->next=NULL;//表示当前链表结束
}</span>

6.单链表的整表删除

将L重置为空表

<span style="font-size:14px;">status ClearList(LinkList *L)
{
    LinkList p,q;
    p=(*L)->next;   //p指向第一个结点
    while(p)     //没到表尾
    {
        q=p->next;
        free(p);
        p=q;
    }
    (*L)->next=NULL;//头指针为空
    return 0k;
}</span>

静态链表实现：

int Malloc_SLL(staticLinkList space)
{
    int i=space[0].cur;//当前数组第一个元素cur储存的值；即准备返回的第一个备用空间的下标
    
    if(space[0].cur)  //由于要拿出来一个分量来使用，所以我们把他的下一个分量来备用
        space[0].cur=space[i].cur;
    return i;
}