C语言：链表实现的一个实例

问题：写一个程序输入你一年看过的所有电影以及每部电影的各种信息（简化问题：每部电影只要求输入片名和评价）

链表实现：

#include<stdio.h>
#include<stdlib.h>//提供malloc()原型
#include<string.h>
#define TSIZE 45
struct film{
    char title[TSIZE];
    int rating;
    struct film * next;
};

int main()
{
    struct film * head = NULL;
    struct film * prev, *current;
    char input[TSIZE];

    //收集并储存信息
    puts("Enter first movie title:");
    while(gets(input)!=NULL&&input[0]!='\0'){
        current = (struct film *)malloc(sizeof(struct film));
        if(head==NULL)
           head=current;
        else
           prev->next=current;
        current->next=NULL;
        strcpy(current->title, input);
        puts("Enter your rating <0-10>:");
        scanf("%d",&current->rating);
        while(getchar()!='\n')
            continue;
        puts("Enter next movie title(empty line to stop):");
        prev=current;
    }

    //给出电影列表
    if(head==NULL)
       printf("No data entered.");
    else
       printf("Here is the movie list:\n");
    current=head;
    while(current!=NULL){
        printf("Movie:%s Rating:%d\n",current->title,current->rating);
        current=current->next;
    } 

    //释放所分配的内存
    current=head;
    while(current!=NULL){
        free(current);
        current=current->next;
    }
    printf("Bye!\n");
    return 0;
}

程序分析：

不使用head遍历整个列表而使用一个新指针current是因为head会改变head的值，这样程序将不再能找到列表的开始处。
由malloc()分配的内存在程序终止时虽然会自动清理，但仍要记得调用free()来释放malloc()分配的内存，养成良好的习惯。

反思：

程序没有检查malloc()是否找到需要的内存，并且没有提供删除列表中项目的功能。

抽象数据类型实现：

1.构造接口

list.h接口文件

#ifndef LIST_H_
#define LIST_H_
#include<stdbool.h>

/*特定程序的声明*/
#define TSIZE 45
struct film
{
    char title[TSIZE];
    int rating;
};

/*一般类型定义*/
typedef struct film Item;

typedef struct node
{
    Item item;
    struct node * next;
}Node;

typedef Node * List;
/*函数原型*/
/*操作：初始化一个列表*/
/*操作前：plist指向一个列表*/
/*操作后：该列表被初始化为空列表*/
void InitializeList(List * plist);

/*操作：确定列表是否为空列表*/
/*操作前：plist指向一个已初始化的列表*/
/*操作后：如果该列表为空则返回true；否则返回false*/
bool ListIsEmpty(const List * plist);

/*操作：确定列表是否已满*/
/*操作前：plist指向一个已初始化的列表*/
/*操作后：如果该列表为空则返回true；否则返回false*/
bool ListIsFull(const List * plist); 

/*操作：确定列表中项目的个数*/
/*操作前：plist指向一个已初始化的列表*/
/*操作后：返回该列表中项目的个数*/
unsigned int ListItemCount(const List * plist);

/*操作：在列表尾部添加一个项目*/
/*操作前：item是要被增加到列表的项目 plist指向一个已初始化的列表*/
/*操作后：如果可能的话，在列表尾部添加一个新项目，函数返回true，否则函数返回false*/
bool AddItem(Item item,List * plist);

/*操作：把一个函数作用于列表中的每个项目*/
/*操作前：plist指向一个已初始化的列表 pfun指向一个函数，该函数接受一个Item参数并且无返回值*/
/*操作后：pfun指向的函数被作用到列表中的每个项目一次*/
void Traverse(const List * plist,void(* pfun)(Item item));

/*操作：释放已分配的内存（如果有）*/
/*操作前：plist指向一个已初始化的列表*/
/*操作后：为该列表分配的内存已被释放并且该列表被置为空列表*/
void EmptyTheList(List * plist);

#endif

2.实现接口：

list.c文件

#include<stdio.h>
#include<stdlib.h>
#include "list.h"
/*局部函数原型*/
static void CopyToNode(Item item,Node * pnode);

/*接口函数*/
/*把列表设置为空列表*/
void InitializeList(List * plist)
{
    * plist = NULL;
}

/*如果列表为空则返回真*/
bool ListIsEmpty(const List * plist)
{
    if(* plist == NULL)
        return true;
    else
        return false;
}

/*如果列表已满则返回真*/
bool ListIsFull(const List * plist)
{
    Node * pt;
    bool full;

    pt = (Node *)malloc(sizeof(Node));
    if(pt==NULL)
        full=true;
    else
        full=false;
    free(pt);
    return full;
}

/*返回节点数*/
unsigned int ListItemCount(const List * plist)
{
    unsigned int count = 0;
    Node * pnode = *plist;
    while(pnode!=NULL)
    {
        ++count;
        pnode=pnode->next;
    }
    return count;
}

/*创建存放项目的节点，并把它添加到由plist指向的列表（较慢的实现方法）尾部*/
bool AddItem(Item item,List * plist)
{
    Node * pnew;
    Node * scan = *plist;

    pnew = (Node *)malloc(sizeof(Node));
    if(pnew==NULL)
        return false;

    CopyToNode(item,pnew);
    pnew->next=NULL;
    if(scan==NULL)
        *plist=pnew;
    else
    {
        while(scan->next!=NULL)
            scan=scan->next;
        scan->next=pnew;
    }
    return true;
}

/*访问每个节点并对它们分别执行由pfun指向的函数*/
void Traverse(const List * plist,void(*pfun)(Item item))
{
    Node *pnode=*plist;
    while(pnode!=NULL)
    {
        (*pfun)(pnode->item);
        pnode=pnode->next;
    }
}

/*释放由malloc()分配的内存*/
/*把列表指针设置为NULL*/
void EmptyTheList(List * plist)
{
    Node * psave;
    while(*plist!=NULL)
    {
        psave=(*plist)->next;
        free(*plist);
        *plist=psave;
    }
}

/*局部函数定义*/
/*把一个项目复制到一个节点中*/
static void CopyToNode(Item item,Node *pnode)
{
    pnode->item=item;
}

3.使用接口：

film.c

#include<stdio.h>
#include<stdlib.h>
#include "list.h"

void showmovies(Item item);

int main(void)
{
    List movies;
    Item temp;

/*初始化*/
    InitializeList(&movies);
    if(ListIsFull(movies))
    {
        fprintf(stderr, "No memory available!Bye!\n");
        exit(1);
    }

/*收集并存储*/
    puts("Enter first movie title:");
    while(gets(temp.title)!=NULL && temp.title[0]!='\0')
    {
        puts("Enter your rating<0-10>:");
        scanf("%d",&temp.rating);
        while(getchar()!='\n')
            continue;
        if(AddItem(temp,&movies)==false)
        {
            fprintf(stderr,"Problem allocating memory\n");
            break;
        }
        if(ListIsFull(movies))
        {
            puts("The list if now full.");
            break;
        }
        puts("Enter next movie title(empty line to stop):");
    }
/*显示*/
    if(ListIsEmpty(movies))
        printf("No data entered.");
    else
    {
        printf("Here is the movie list:\n");
        Traverse(&movies,showmovies);
    }
    printf("You entered %d movies.\n",ListItemCount(&movies));

/*清除*/
    EmptyTheList(&movies);
    printf("Bye!\n");
    return 0;
}

void showmovies(Item item)
{
    printf("Movies:%s Rating:%d\n",item.title,item.rating);
} 

注意：

整个程序由三个文件组成，要运行这个程序，必须编译并链接film.c和list.c（关于编译多文件程序）,工程建立如下：

反思：

使用ADT方法带来了什么？
1.使用链表的方式暴露了所有编程的细节，而使用ADT方法则隐藏了这些细节，并用与任务直接相关的语言来表达程序。
2.list.h和list.c文件共同组成可重用的资源。如果需要另一个简单列表，仍可用这些头文件。

程序新知：

1.“C预处理器和C库”中的#ifndef技术对多次包含一个文件提供保护
2.“文件输入输出”fprintfgetc()函数等的使用
3.编译多文件程序