大学实验3指导：利用单链表实现A-B

实验目的：深入理解单链表的建立及操作

实验内容：

1．建立单链表A与B

2．实现主要的函数，查找、插入、删除等

3．实现操作A-B

步骤1：包含必要的函数库，对结构体LNode中的抽象数据类型ElemType进行具体定义

 #include <stdio.h>

 #include <stdlib.h>

 typedef int ElemType;

步骤2：定义结构体LNode

 typedef struct LNode

 {

      ElemType data;

      struct LNode *next;

 }LNode, *LinkList;

F提示：LNode用于声明单链表中的一个数据结点，LinkList用于声明指向单链表中的数据结点的指针

步骤3：定义基本的函数InitList_L()、ListInsert_L()、GetElem_L ()、ListSize_L()，用于建立单链表A和B

步骤3.1：实现函数InitList_L()。（该函数用于对单链表进行初始化，即创建头结点）

F提示1：参数L为指向“单链表头指针”的指针，即

LinkList *L;

等价于

LNode **L;

F提示2：由于需要在函数中修改L所指向的头指针的内容（即调用InitList_L()之前，头指针为空，调用InitList_L()之后，头指针指向新创建的头结点），因此需要在L前加“*”号。

F提示3：由于*L表示头指针的内容，因此在修改头结点的next域时，可以执行：

(*L)->next=NULL

由于在a为指向结构体的指针时，运算a->b等价于(*a).b，因此该语句等价于：

(*(*L)).next=NULL;

 void InitList_L(LinkList *L)

 {

      *L=(LinkList)malloc(sizeof(LNode));

      if (*L==NULL)

          exit(-);

      (*L)->next=NULL;

      //等价于(*(*L)).next=NULL;                                              

 }

步骤3.2：实现函数ListInsert_L ()。（在指定位置上插入新元素）

 int ListInsert_L(LinkList L,int i,ElemType e)

 {
     LNode *p,*s;
     int j;
     p=L;
     j=;
     while(p&&j<i-)
     {
         p=p->next;++j;
     }
     if(!p||j>i-)
         return ;
      s=(LinkList)malloc(sizeof(LNode));
      s->data=e;
      s->next=p->next;
      p->next=s;
      return ;
  }

步骤3.3：GetElem_L()。（返回顺序表中指定位置上的元素）

 int GetElem_L(LinkList L, int i, ElemType *e)
 {
     LinkList p;
     int j=;
     p=L->next;
     while(p&&j<i)
     {
         p=p->next;
         ++j;
     }
     if(!p||j>i)
         return ;
     *e=p->data;
     return ;
 }

步骤3.4：ListSize_L()。（返回单链表的长度）

 int ListSize_L(LinkList L)
 {
     LNode *p;
     int count=;
     p=L;
     while(p->next!=NULL)
     {
         p=p->next;
         count++;
     }
     return count;
 }

步骤4：建立线性表A与B，并输出其中的元素

F提示：采用静态方式创建A=(3,5,8,11)，B=(2,6,8,9,11,15,20)。

 int main()
 {
     int i,flag,e;
     //定义两个头指针
     LinkList A,B;
     //测试函数GetElemPointer_L()
     LNode *p;
     /*初始化单链表A，将头指针A的地址（即指向A的指针）传入*/
     InitList_L(&A);
     /*初始化单链表B，将头指针B的地址（即指向B的指针）传入*/
     InitList_L(&B);
     /*为单链表A填充数据*/
     ListInsert_L(A,,);
     …
     ListInsert_L(A,,);
     /*为单链表B填充数据*/
     ListInsert_L(B,,);
     …
     ListInsert_L(B,,);
     /*输出单链表A*/
     printf("单链表A中的元素为：\n");
     for(i=;i<=ListSize_L(A);i++)
     {
         flag=GetElem_L(A,i,&e);
         if(flag)
             printf("%4d",e);
     }
     printf("\n");
     /*输出单链表B*/
     printf("单链表B中的元素为：\n");
     for(i=;i<=ListSize_L(B);i++)
     {
         flag=GetElem_L(B,i,&e);
         if(flag)
         printf("%4d",e);
     }
     printf("\n");
 }

步骤4的输出结果

步骤5：实现函数ListDelete_L()。（用于删除指定位置上的元素）

F提示：该函数的声明为：

 int ListDelete_L(LinkList *L,int i, ElemType *e)

步骤6：测试函数ListDelete_L()

     flag=ListDelete_L(&B,,&e);
     if(flag)
     printf("被删除的元素为:%4d",e);
     printf("\n");
     printf("单链表B中的剩余元素为：\n");
     for(i=;i<=ListSize_L(B);i++)
     {
         flag=GetElem_L(B,i,&e);
         if(flag)
         printf("%4d",e);
     }
     printf("\n");

步骤6的输出结果

步骤7：实现函数LocateElem_L
()

LocateElem_L()：返回给定元素在单链表中的位置（序号）。注意：头结点的序号为0。

F提示：首先，令p指向单链表的表头结点，即L->next。若单链表为空，即L->next==NULL，则返回0。否则，对单链表进行遍历，并返回匹配结点的位置。最后，若最终没有找到，则返回0。

该函数声明为：

 int LocateElem_L(LinkList L, ElemType e);

步骤8：测试函数LocateElem_L()

 flag=LocateElem_L(B,);
 printf("元素15在单链表B中的位置为：%4d\n",flag); 

步骤8的输出结果

步骤9：实现函数GetElemPointer_L()。（返回指向单链表中第i个元素的指针）

F提示：首先，若单链表为空，即L->next==NULL，则返回空指针。接下来，若参数i非法，则返回空指针。然后，对单链表进行遍历，并返回匹配结点的指针。最后，若最终没有找到，则返回空指针。

该函数声明为：

 LNode *GetElemPointer_L(LinkList L,int i);

步骤10：测试函数GetElemPointer_L()

 p=GetElemPointer_L(A,);
 printf("单链表A中的第3个元素为：%4d\n",p->data);

步骤10的输出结果

步骤11：实现函数DelElem_L()（实现A-B）。

F提示：利用循环遍历顺序表B。在每轮循环中，先利用函数GetElemPointer_L()取得指向B中的当前结点的指针（假设该结点指针保存在p中），再利用函数LocateElem_L()检查中A是否存在数据域等于p->data的结点，若存在则返回匹配结点的位置pos。最后，利用函数ListDelete_L()删除所匹配的结点（即A中的第pos个结点）。

函数DelElem_L()的声明如下：

 void DelElem_L(LinkList A,LinkList B);

步骤12：测试函数DelElem_L()的功能

     DelElem_L(A,B);//执行A-B
     printf("单链表A中的剩余元素为：\n");
     for(i=;i<=ListSize_L(A);i++)
     {
         flag=GetElem_L(A,i,&e);
         if(flag)
         printf("%4d",e);
     }
     printf("\n");

步骤12的输出结果

思考题

1．将有关单链表的所有基本函数组织成单独的文件“LinkList.h”，然后利用include命令调用该文件。

 /*删除指定位置上的元素*/
 int ListDelete_L(LinkList *L,int i, ElemType *e) {
     LNode *p,*q;
     p=*L;
     int j=;
     while(p->next&&j<i-) {
         p=p->next;
         ++j;
     }
     if(!(p->next)||j>i-) return ;
     q=p->next;
     p->next=q->next;
     *e=q->data;
     free(q);
     return ;
 }

 /*返回给定元素在单链表中的位置*/
 int LocateElem_L(LinkList L, ElemType e) {
     LNode *p;
     int i;
     if(L->next==NULL)
         return ;
     p=L->next;
     i=;
     while(p) {

         if(p->data==e)
             return i;
         else {
             p=p->next;
             i++;
         }
         if(!p) return ;
     }
 }

 /*返回指向单链表中第i个元素的指针*/
 /*若找到第i个结点，则返回指向该结点的指针；否则，返回空指针*/
 LNode *GetElemPointer_L(LinkList L,int i) {
     LNode *p;
     int j;
 //若单链表为空
     if(L->next==NULL)
         return NULL;
 //若参数非法
     if(i<)
         return NULL;
     p=L;
     j=;
     while(p->next!=NULL&&j<i) {
         p=p->next;
         j++;
     }
     if(j==i)
         return p;
     else
         return NULL;
 }

 void DelElem_L(LinkList A,LinkList B) {
     int i,pos,flag;
     ElemType e;
     LNode *p;
     for(i=; i<=ListSize_L(B); i++) {
         p=GetElemPointer_L(B,i);//p指向单链表B中存在第i个结点
         if(p) { //若单链表B中存在第i个结点
             pos=LocateElem_L(A,p->data);//若A中存在相同的结点，则用返回其在A中的位置
             if(pos>)//若存在，则在A中删除该元素
                 ListDelete_L(&A,pos,&e);
             /*
             {flag=ListDelete_L(&A,pos,&e);
              if(flag)
              printf("被删除的元素为：%4d\n",e);
              }
              */
         }
     }
 }