线性表（顺序表示，链式表示，一元多项式相加）



1.线性表的定义和特点：

元素之间的关系是线性，同一张线性表中的元素必定具有相同的特征。

线性表是一个相当灵活的数据，长度可以根据需要增长或缩短，对元素进行访问，插入和删除。

抽象数据类型线性表的定义如下：

ADT List{

        数据对象：D={ai | ai ∈ ElemSet, i=1,…,n}

        数据关系：R={< ai-1 , ai > | ai-1 , ai ∈ D}

        基本操作 ：

                  1.  初始化   InitList(&L)

                  2.  取值       GetElem(L, i, &e)

                  3.  查找       LocateElem(L, e, compare())

                  4.  插入       ListInsert(&L, i, e)

                  5.  删除       ListDelete(&L, i, &e)

                   ……

    } ADT List

初始化：InitList(&L)

        操作结果：构造一个空的线性表L。

取值：GetElem(L, i, &e)

        初始条件：线性表L已存在，1≤i≤ListLength(L)。

        操作结果：用e返回L中第i个数据元素的值。

• 2.线性表的顺序表示和实现

线性表的顺序表示又称为 顺序存储结构或 顺序映像。逻辑上和物理上都相邻。

顺序存储定义：把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构。

顺序存储方法：用一组地址连续的存储单元依次存储线性表的元素，可通过数组V[n]来实现。

线性表中的第i个元素的存储位置满足上式。

顺序存储结构类型定义：

#define MAXSIZE 10000  // 顺序表的最大长度

typedef struct {   // 数据元素定义     

     char no[20];              // 图书ISBN

     char name[50];  // 图书名字

     float price;   // 图书价格

     ……

} ElemType;    （Book）

typedef struct{

      ElemType *elem;        // 存储空间的基地址

      int length;         // 顺序表中当前数据元素个数

}SqList;         // 顺序存储结构类型为 SqList

线性表的重要基本操作的算法实现：

1. 初始化线性表L （ 参数用引用）

Status InitList(SqList &L){   

    //构造一个空的顺序表L

    L.elem = new ElemType[MAXSIZE];

                                                                    //为顺序表分配空间

    if(! L.elem)

          exit(OVERFLOW);                        //存储分配失败

    L.length=0;                         //空表长度为0

    return OK;

}

2. 初始化线性表L （ 参数用指针）

Status InitList(SqList *L){   

    //构造一个空的顺序表L

    L-> elem = new ElemType[MAXSIZE];

                                                                    //为顺序表分配空间

    if(! L-> elem)

          exit(OVERFLOW);                        //存储分配失败

    L-> length=0;                        //空表长度为0

    return OK;

}

3.取值（根据位置i获取相应位置元素的内容）

int GetElem(SqList L, int i, ElemType &e){

      if (i<1||i>L.length) return ERROR;  

               //判断i值是否合理，若不合理，返回ERROR

        e = L.elem[i-1];   //第i-1的单元存储着第i个数据

       return OK;

}

4.查找（根据指定数据获取数据所在的位置）查找元素e

int LocateELem(SqList L, ElemType e){

   for (i=0;i< L.length;i++){

       if (L.elem[i]==e)

        return i+1;        

     }      

     return 0;

}

5.插入

（1）判断插入位置 i 是否合法。

（2）判断顺序表的存储空间是否已满。     

（3）将第n至第 i 位的元素依次向后移动一个位置，

          空出第i个位置。

（4）将要插入的新元素e放入第i个位置。

（5）表长加1，插入成功返回OK。

插入元素e：

  Status ListInsert(SqList &L,int i ,ElemType e){

        if(i<1 || i>L.length+1)

             return ERROR;             //i值不合法

        if(L.length==MAXSIZE)

             return ERROR;                   //当前存储空间已满    

        for(j=L.length-1; j>=i-1; j--)

              L.elem[j+1]= L.elem[j];      //插入位置及之后的元素后移

        L.elem[i-1]=e;                            //将新元素e放入第i个位置

        L.length++;              //表长增1

        return OK;

   }

6.删除第i个元素

  Status ListDelete(SqList &L, int I, ElemType &e){

        if((i<1)||(i>L.length))

             return ERROR;             // i值不合法

        e = L.elem[i-1];                         //第 i 个元素保留在e中

        for (j=i; j<=L.length-1; j++)                  

　  　   L.elem[j-1]=L.elem[j];        //被删除元素之后的元素前移

        L.length--;                            //表长减1

        return OK;                               //删除成功

   }

顺序表的查找、插入、删除算法的平均时间复杂度为T(n)=O(n)

• 3.线性表的链式存储结构

一、线性列表

链式存储结构：用 任意的存储单位存储线性表的数据结构，结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。

线性表的链式表示又称为 非顺序映像或 链式映像。

结点：数据元素的存储映像。存储其本身的信息和一个知识其直接后继的信息。

由数据域和指针域两部分组成：

数据域：存储数据元素信息；

指针域：存储直接后继结点的存储位置，其中存储的信息称为指针或者是链

链表：n个结点链结成一个链表（线性表的链式存储结构）。链表的每一个结点中只包含一个指针域故又称为线性链表或者单链表。

头指针：指向链表中头结点的指针

首元结点：指链表中存储第一个数据元素a1的结点

头结点：在链表的首元结点之前附设的一个结点；数据域内只放空表标志和表长等信息或为空所以他不计入链表长度值。

顺序存取法，访问第一个结点和最后一个节点的时间不等。

算法描述：

1.插入：s->next=p->next;      p->next=s

步骤：（1）找到ai-1存储位置p

          （2）生成一个新结点*s

          （3）将新结点*s的数据域置为x

          （4）新结点*s的指针域指向结点ai

          （5）令结点*p的指针域指向新结点*s

Status ListInsert_L(LinkList &L,int i,ElemType e){

     p=L;j=0;

      while(p&&j<i−1){p=p->next;++j;}  // 寻找第i−1个结点

      if(!p)  return ERROR;  // i大于表长 + 1或者小于1

      s=new LNode;  // 生成新结点s，将该结点的初始位置赋值给指针变量s

       s->data=e;                    // 将结点s的数据域置为e

      s->next=p->next;                  // 将结点s插入L中

      p->next=s;

      return OK;

}//ListInsert_L

2.删除：p->next = p->next->next

步骤：（1）找到ai-1存储位置p

          （2）临时保存结点ai的地址在q中，以备释放

          （3）令p->next指向ai的直接后继结点

          （4）将ai的值保留在e中

          （5）释放ai的空间

Status ListDelete_L(LinkList &L,int i,ElemType &e){

    p=L;j=0;

    while(p->next &&j<i-1){//寻找第i个结点，并令p指向其前驱

        p=p->next; ++j;

    }

    if(!(p->next)||j>i-1) return ERROR; //删除位置不合理

     q=p->next;                 // 临时保存被删结点的地址以备释放

    p->next=q->next;       // 改变删除结点前驱结点的指针域

    e=q->data;                   // 保存删除结点的数据域

    delete q;                   // 释放删除结点的空间

return OK;

}//ListDelete_L

查找，从前插入和删除的时间复杂度都是 O(n)，因为要从头查找前驱结点。

单链表和顺序存储结构不同他是一种 动态结构。整个可用存储空间可为多个链表共同享用，每个链表占用的空间不需预先分配划定，而是可以由系统应需要即时生成。

动态生成链表的过程：从“空表”的初始状态起，依次建立各元素结点，并逐个插入链表。

从表尾到表头逆向建立单链表：

void CreateList_F(LinkList &L,int n){

      L=new LNode;

      L->next=NULL; //先建立一个带头结点的单链表

      for(i=n;i>0;--i){

        p=new LNode; //生成新结点

        cin>>p->data; //输入元素值

        p->next=L->next; L->next=p;   //插入到表头

     }

}//CreateList_F

二、循环列表

从循环链表中的任何一个结点的位置都可以找到其他所有结点。

三、双向列表

1.存储结构：

typedef struct DuLNode{

    ElemType   data;             

    struct DuLNode  *prior;

    struct DuLNode  *next;

}DuLNode, *DuLinkList

2.双向表的插入：

Status ListInsert_DuL(DuLinkList &L,int i,ElemType e){

   if(!(p=GetElemP_DuL(L,i))) return ERROR;

   s=new DuLNode;

    s->data=e;

   s->prior=p->prior;

   s->next=p;

   p->prior->next=s;

   p->prior=s;

   return OK;

}

3.双向表的删除：

Status ListDelete_DuL(DuLinkList &L,int i,ElemType &e){

   if(!(p=GetElemP_DuL(L,i)))     return ERROR;

    e=p->data;

   p->prior->next=p->next;

   p->next->prior=p->prior;

   delete p;

   return OK;

}

顺序表和链表之间的比较：

• 4、一元多项式的表示及相加

算法步骤：

① 指针p1和p2初始化，分别指向Pa和Pb的首元结点。

② p3指向和多项式的当前结点，初值为Pa的头结点。

③ 当指针p1和p2均未到达相应表尾时，则循环比较p1和p2所指结点对应的指数值（p1->expn与p2->expn），有下列3种情况：

* 当p1->expn等于p2->expn时，则将两个结点中的系数相加，若和不为零，则修改p1所指结点的系数值，同时删除p2所指结点，若和为零，则删除p1和p2所指结点；

* 当p1->expn小于p2->expn时，则应摘取p1所指结点插入到“和多项式”链表中去；

* 当p1->expn大于p2->expn时，则应摘取p2所指结点插入到“和多项式”链表中去。

④ 将非空多项式的剩余段插入到p3所指结点之后。

⑤ 释放Pb的头结点。

多项式加法：

void AddPolyn(polynomial &Pa,polynomial &Pb){

ha=GetHead (Pa);hb=GetHead (Pb);  //ha和hb分别指向Pa和Pb的头结点

qa=NextPos(Pa,ha); qb=NextPos(Pb,hb);   //qa和qb分别指向Pa和Pb的当前结点

while(qa&&qb){  //qa和qb都不为空

  a=GetCurElem(qa);b=GetCurElem(qb);//a和b为两表中当前比较的元素

  switch(* cmp(a,b)){    //a和b的值进行比较

        case -1:  //a<b

           ha=qa;qa=NextPos(Pa,qa);break;

       case 0:  

sum=a.coef+b.coef;

if(sum!=0.0){   //修改多项式Pa中当前节点的系数值

    SetCurElem(qa,sum);ha=qa;}

else{   //删除Pa中当前结点

    DelFirst(ha,qa);FreeNode(qa);}

DelFirst(hb,qb);FreeNode(qb);qb=NextPos(Pb,hb);

qa=NextPos(Pa,ha);break;

case 1:  //a>b

DelFirst(hb,qb);InsFirst(ha,qb);

qb=NextPos(Pb,hb);ha=NextPos(Pa,ha);break;

    }//switch

}//while

if(!ListEmpty(Pb)) Append(Pa,qb);//链接Pb剩余结点

FreeNode(hb);

}

有序表的合并：

void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc){

   pa=La->next;

   pb=Lb->next;

   pc=Lc=La;             //用La的头结点作为Lc的头结点

   while(pa && pb){

      if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next;}

      else{pc->next=pb; pc=pb; pb=pb->next;}

   pc->next=pa?pa:pb;    //插入剩余段

   delete Lb;             //释放Lb的头结点

}