大学实验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(-1);

     (*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=0;
    while(p&&j<i-1)
    {
        p=p->next;++j;
    }
    if(!p||j>i-1) 
        return 0;
     s=(LinkList)malloc(sizeof(LNode));
     s->data=e;
     s->next=p->next;
     p->next=s;
     return 1;
 }

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

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

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

 

int ListSize_L(LinkList L)
{
    LNode *p;
    int count=0;
    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,1,3);
    …
    ListInsert_L(A,4,11);
    /*为单链表B填充数据*/
    ListInsert_L(B,1,2);
    …
    ListInsert_L(B,7,20);
    /*输出单链表A*/
    printf("单链表A中的元素为：
"); 
    for(i=1;i<=ListSize_L(A);i++)
    {
        flag=GetElem_L(A,i,&e);
        if(flag)
            printf("%4d",e);
    }
    printf("
");
    /*输出单链表B*/
    printf("单链表B中的元素为：
"); 
    for(i=1;i<=ListSize_L(B);i++)
    {
        flag=GetElem_L(B,i,&e);
        if(flag)
        printf("%4d",e);
    }
    printf("
");
}

步骤4的输出结果

 

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

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

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

步骤6：测试函数ListDelete_L()

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

步骤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,15);
printf("元素15在单链表B中的位置为：%4d
",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,3);
printf("单链表A中的第3个元素为：%4d
",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中的剩余元素为：
"); 
    for(i=1;i<=ListSize_L(A);i++)
    {
        flag=GetElem_L(A,i,&e);
        if(flag)
        printf("%4d",e);
    }
    printf("
");

步骤12的输出结果

思考题

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

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

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

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

/*返回指向单链表中第i个元素的指针*/
/*若找到第i个结点，则返回指向该结点的指针；否则，返回空指针*/
LNode *GetElemPointer_L(LinkList L,int i) {
    LNode *p;
    int j;
//若单链表为空
    if(L->next==NULL)
        return NULL;
//若参数非法
    if(i<1)
        return NULL;
    p=L;
    j=0;
    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=1; 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>0)//若存在，则在A中删除该元素
                ListDelete_L(&A,pos,&e);
            /*
            {flag=ListDelete_L(&A,pos,&e);
             if(flag)
             printf("被删除的元素为：%4d
",e);
             }
             */
        }
    }
}