链表ADT的实现

list.h文件

         /*链表的类型声明*/

         typedef int ElementType;

 /* START: fig3_6.txt */
         #ifndef _List_H
         #define _List_H

         struct Node;
         typedef struct Node *PtrToNode;
         typedef PtrToNode List;
         typedef PtrToNode Position;

         List MakeEmpty( List L );
         int IsEmpty( List L );
         int IsLast( Position P, List L );
         Position Find( ElementType X, List L );
         void Delete( ElementType X, List L );
         Position FindPrevious( ElementType X, List L );
         void Insert( ElementType X, List L, Position P );
         void DeleteList( List L );
         Position Header( List L );
         Position First( List L );
         Position Advance( Position P );
         ElementType Retrieve( Position P );

         #endif    /* _List_H */
 /* END */

list.c文件

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

         /* Place in the interface file */
         struct Node
         {
             ElementType Element;
             Position    Next;
         };

         /*创建空链表*/
         List
         MakeEmpty( List L )
         {
             if( L != NULL )
                 DeleteList( L );
             L = malloc( sizeof( struct Node ) );
             if( L == NULL )
                 FatalError( "Out of memory!" );
             L->Next = NULL;
             return L;
         }

 /* START: fig3_8.txt */
         /* Return true if L is empty */

         /*判断链表是否为空*/
         int
         IsEmpty( List L )
         {
             return L->Next == NULL;
         }
 /* END */

 /* START: fig3_9.txt */
         /* Return true if P is the last position in list L */
         /* Parameter L is unused in this implementation */

         /*判断是否为链表的最后元素*/
         int IsLast( Position P, List L )
         {
             return P->Next == NULL;
         }
 /* END */

 /* START: fig3_10.txt */
         /* Return Position of X in L; NULL if not found */

         /*找某元素的位置*/
         Position
         Find( ElementType X, List L )
         {
             Position P;

 /**/      P = L->Next;
 /**/      while( P != NULL && P->Element != X )
 /**/          P = P->Next;

 /**/      return P;
         }
 /* END */

 /* START: fig3_11.txt */
         /* Delete from a list */
         /* Cell pointed to by P->Next is wiped out */
         /* Assume that the position is legal */
         /* Assume use of a header node */

         /*删除链表某个元素*/
         void
         Delete( ElementType X, List L )
         {
             Position P, TmpCell;

             P = FindPrevious( X, L );

             if( !IsLast( P, L ) )  /* Assumption of header use */
             {                      /* X is found; delete it */
                 TmpCell = P->Next;
                 P->Next = TmpCell->Next;  /* Bypass deleted cell */
                 free( TmpCell );
             }
         }
 /* END */

 /* START: fig3_12.txt */
         /* If X is not found, then Next field of returned value is NULL */
         /* Assumes a header */

         /*找某个元素的前一个元素*/
         Position
         FindPrevious( ElementType X, List L )
         {
             Position P;

 /**/      P = L;
 /**/      while( P->Next != NULL && P->Next->Element != X )
 /**/          P = P->Next;

 /**/      return P;
         }
 /* END */

 /* START: fig3_13.txt */
         /* Insert (after legal position P) */
         /* Header implementation assumed */
         /* Parameter L is unused in this implementation */

         /*在某个位置后面插入一个元素*/
         void
         Insert( ElementType X, List L, Position P )
         {
             Position TmpCell;

 /**/      TmpCell = malloc( sizeof( struct Node ) );
 /**/      if( TmpCell == NULL )
 /**/          FatalError( "Out of space!!!" );

 /**/      TmpCell->Element = X;
 /**/      TmpCell->Next = P->Next;
 /**/      P->Next = TmpCell;
         }
 /* END */

 #if 0
 /* START: fig3_14.txt */
         /* Incorrect DeleteList algorithm */

         void
         DeleteList( List L )
         {
             Position P;

 /**/      P = L->Next;  /* Header assumed */
 /**/      L->Next = NULL;
 /**/      while( P != NULL )
             {
 /**/          free( P );
 /**/          P = P->Next;
             }
         }
 /* END */
 #endif

 /* START: fig3_15.txt */
         /* Correct DeleteList algorithm */

         /*删除链表*/
         void
         DeleteList( List L )
         {
             Position P, Tmp;

 /**/      P = L->Next;  /* Header assumed */
 /**/      L->Next = NULL;
 /**/      while( P != NULL )
             {
 /**/          Tmp = P->Next;
 /**/          free( P );
 /**/          P = Tmp;
             }
         }
 /* END */

         /*返回头结点*/
         Position
         Header( List L )
         {
             return L;
         }

         /*返回第一个节点*/
         Position
         First( List L )
         {
             return L->Next;
         }
         /*返回某节点的下一个节点*/
         Position
         Advance( Position P )
         {
             return P->Next;
         }

         /*返回某节点的值*/
         ElementType
         Retrieve( Position P )
         {
             return P->Element;
         }