算法（1）—— 链表、栈的实现

GitHub :  https://github.com/hanxloop/c_dev_library

前几天码了链表和栈，栈有数组实现和链表实现，自己跑了书上的示例，能跑的通，开心，接口、实现和测试分离，实现后我会补充一些使用这些代码完成的练习题目。

0.错误提示

该文件打印程序运行时出错信息。

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

#define Error( Str )        FatalError( Str )
#define FatalError( Str )   fprintf( stderr, "%s
", Str ), exit( 1 )

１. 链表

/*list.c*/

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

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;
}

int IsEmpty( List L )  {
  return L->Next == NULL;
}

int IsLast( Position P, List L )  {
  return P->Next == NULL;
}

Position Find( ElementType X, List L )  {
  Position P;
  P = L->Next;
  
  while( P != NULL && P->Element != X )
    P=Advance(P);          //P = P->Next; OK
  
  return P;
}




void Delete( ElementType X, List L )  {
  Position P, TmpCell;

  P = FindPrevious( X, L );

  if( !IsLast( P, L ) )  {                   
    TmpCell = P->Next;
    P->Next = TmpCell->Next;  
    free( TmpCell );
  }
}

Position FindPrevious( ElementType X, List L )
{
  Position P;
  P = L;

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

  return P;
}


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;
}




void DeleteList( List L ) {
  Position P, Tmp;
  P = L->Next; 
  L->Next = NULL;
  
  while( P != NULL ) {
    Tmp = P->Next;  
    //Tmp = Tmp->Next;    OK
    free( P );
    P = Tmp;
  }
}


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;
}

/*list.c*/

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

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;
}

int IsEmpty( List L )  {
  return L->Next == NULL;
}

int IsLast( Position P, List L )  {
  return P->Next == NULL;
}

Position Find( ElementType X, List L )  {
  Position P;
  P = L->Next;
  
  while( P != NULL && P->Element != X )
    P=Advance(P);          //P = P->Next; OK
  
  return P;
}




void Delete( ElementType X, List L )  {
  Position P, TmpCell;

  P = FindPrevious( X, L );

  if( !IsLast( P, L ) )  {                   
    TmpCell = P->Next;
    P->Next = TmpCell->Next;  
    free( TmpCell );
  }
}

Position FindPrevious( ElementType X, List L )
{
  Position P;
  P = L;

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

  return P;
}


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;
}




void DeleteList( List L ) {
  Position P, Tmp;
  P = L->Next; 
  L->Next = NULL;
  
  while( P != NULL ) {
    Tmp = P->Next;  
    //Tmp = Tmp->Next;    OK
    free( P );
    P = Tmp;
  }
}


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;
}

/*testlist.c*/

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

void PrintList( const List L );  



int main(int argc, char *argv[])   {
  List L;
  Position P;
  int i;

  L = MakeEmpty( NULL );
  P = Header( L );
  PrintList( L );

  for( i = 0; i < 10; i++ ) {
      Insert( i, L, P );
      PrintList( L );
      P = Advance( P );
    }
  
  for( i = 0; i < 10; i+= 2 )
    Delete( i, L );

  /*  for( i = 0; i < 10; i++ )
      if( ( i % 2 == 0 ) == ( Find( i, L ) != NULL ) )
      printf( "Find fails
" );   */

  printf( "Finished deletions
" );

  PrintList( L );

  DeleteList( L );

  return 0;
  
}


 void PrintList( const List L )   {
  Position P = Header( L );

  if( IsEmpty( L ) )
    printf( "Empty list
" );
  else  {
    do   {
      P = Advance( P );
      printf( "%d ", Retrieve( P ) );
    } while ( !IsLast( P, L ) );
    
    printf( "
" );
  }
}

2. 链栈

/* stackli.h */

#ifndef STACK_H
#define STACK_H

struct Node;
typedef int ElementType;
typedef struct Node *PtrToNode;
typedef PtrToNode Stack;

int IsEmpty( Stack S );
Stack CreateStack( void );
void DisposeStack( Stack S );
void MakeEmpty( Stack S );
void Push( ElementType X, Stack S );
ElementType Top( Stack S );
void Pop( Stack S );

#endif

/* stackli.c */

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

struct Node  {
  ElementType Element;
  PtrToNode   Next;
};


int IsEmpty( Stack S )  {
  return S->Next == NULL;
}



Stack  CreateStack( void )  {
  Stack S;

  S = malloc( sizeof( struct Node ) );
  if( S == NULL )
    FatalError( "Out of space!!!" );
  S->Next = NULL;
  MakeEmpty( S );
  return S;
}

void  MakeEmpty( Stack S )  {
  if( S == NULL )
    Error( "Must use CreateStack first" );
  else
    while( !IsEmpty( S ) )
      Pop( S );
}


void  DisposeStack( Stack S )  {
  MakeEmpty( S );
  free( S );
}


void  Push( ElementType X, Stack S )  {
  PtrToNode TmpCell;

  TmpCell = malloc( sizeof( struct Node ) );
  if( TmpCell == NULL )
    FatalError( "Out of space!!!" );
  else   {
      TmpCell->Element = X;
      TmpCell->Next = S->Next;
      S->Next = TmpCell;
    }
}



ElementType  Top( Stack S )  {
  if( !IsEmpty( S ) )
    return S->Next->Element;
  Error( "Empty stack" );
  return 0;  
}


void  Pop( Stack S )  {
  PtrToNode FirstCell;

  if( IsEmpty( S ) )
    Error( "Empty stack" );
  else {
      FirstCell = S->Next;
      S->Next = FirstCell->Next;
      free( FirstCell );
    }
}

/* teststkl.c */

#include <stdio.h>
#include "stackli.c"

int main( )
{
    Stack S;
    int i;

    S = CreateStack( );
    for( i = 0; i < 10; i++ )
        Push( i, S );

    while( !IsEmpty( S ) )
    {
        printf( "%d
", Top( S ) );
        Pop( S );
    }

    DisposeStack( S );
    return 0;
}

3. 数组栈

/* stackar.h */

#ifndef _Stack_h
#define _Stack_h

typedef int ElementType;
struct StackRecord;
typedef struct StackRecord *Stack;

int IsEmpty( Stack S );
int IsFull( Stack S );
Stack CreateStack( int MaxElements );
void DisposeStack( Stack *S );
void MakeEmpty( Stack S );
void Push( ElementType X, Stack S );
ElementType Top( Stack S );
void Pop( Stack S );
ElementType TopAndPop( Stack S );

#endif 

/* stackar.c */

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

#define EmptyTOS ( -1 )
#define MinStackSize ( 5 )

struct StackRecord   {
  int Capacity;
  int TopOfStack;
  ElementType *Array;
};


int IsEmpty( Stack S )  {
  return S->TopOfStack == EmptyTOS;
}


int IsFull( Stack S )  {
  return S->TopOfStack == S->Capacity - 1;
}


Stack  CreateStack ( int MaxElements )  {
  Stack S;

  if( MaxElements < MinStackSize )
    Error( "Stack size is too small" );

  S = malloc( sizeof( struct StackRecord ) );
  if( S == NULL )
    FatalError( "Out of space!!!" );

  S->Array = malloc( sizeof( ElementType ) * MaxElements );
  if( S->Array == NULL )
    FatalError( "Out of space!!!" );
  S->Capacity = MaxElements;
  MakeEmpty( S );

  return S;
}


void  MakeEmpty( Stack S )  {
  S->TopOfStack = EmptyTOS;
}

void  DisposeStack( Stack *S )  {
  if( S != NULL )   { 
    free( (*S)->Array );
    free( *S );
  }
}


void  Push( ElementType X, Stack S )  {
  if( IsFull( S ) )
    Error( "Full stack" );
  else
    S->Array[ ++S->TopOfStack ] = X;
}



ElementType  Top( Stack S )  {
  if( !IsEmpty( S ) )
    return S->Array[ S->TopOfStack ];
  else {
    Error( "Empty stack" );
    return 0;  /* Return value used to avoid warning */
  }
}

void  Pop( Stack S )  {
  if( IsEmpty( S ) )
    Error( "Empty stack" );
  else
    S->TopOfStack--;
}


ElementType  TopAndPop( Stack S )  {
  if( !IsEmpty( S ) )
    return S->Array[ S->TopOfStack-- ];
  Error( "Empty stack" );
  return 0; 
}

/*teststka.c  */

#include <stdio.h>
#include "stackar.c"

int main()  {
  Stack S;
  int i;

  S = CreateStack( 12 );
  for( i = 0; i < 10; i++ )
    Push( i, S );

  while( !IsEmpty( S ) )   {
    printf( "%d
", Top( S ) );
    Pop( S );
  }

  DisposeStack( &S );
  return 0;
}