单链表——游标实现

/*
  单链表游标实现
  特性：
       1.数据存储在一组结构体中。
       2.动态管理内存
  游标实现：
  1.为满足特性1，创建一个全局的结构体数组CursorSpace[SPACE],数组下标充当地址 
  2.用数组实现动态管理。当Next等于0表示空间已满，单元0为表头提供可用空间位置
*/

/*接口头文件*/
typedef int ElementType;
#ifndef _CURSOR_H
#define _CURSOR_H
#include <stdbool.h>

typedef int PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;

/*操作集*/
void InitializeCursorSpace( void );
List MakeEmpty( List L );
bool IsEmpty( List L );
bool IsLast( Position P );
Position Header( List L );
Position First( List L );
Position Find( ElementType X, List L );
Position FindPrevious( ElementType X, List L );
void Delete( ElementType X, List L );
void DeleteList( List L );
void Insert( ElementType X, List L, Position P );
Position Advance( Position P );
ElementType Retrieve( Position P );
void PrintfList( List L );

#endif  

/*接口实现*/
#include <stdio.h>
#include <stdlib.h>
#include "cursor.h"
#define SPACE 11

/*特定结构声明*/
struct Node
{
    ElementType Element;
    Position Next;
};

/*游标数组*/
struct Node CursorSpace[SPACE];      //全局结构体数组

/*动态内存管理*/ 
static Position CursorAlloc( void );
static void CursorFree( Position P );

/*初始化游标数组CursorSpace[SPACE]*/
void InitializeCursorSpace( void )
{
    Position P;
    
    for ( P = 0; P < SPACE - 1; P++ )
        CursorSpace[ P ].Next = P + 1;
    CursorSpace[ SPACE - 1 ].Next = 0;
}

List MakeEmpty( List L )
{
    L = CursorAlloc();
    if ( L == 0 )
    {
       printf( "No Space!!!
");
       exit( 1 );
    }
    CursorSpace[ L ].Next = 0;
    return L;
    
}

bool IsEmpty( List L )
{
    return CursorSpace[ L ].Next == 0;
}

bool IsLast( Position P )
{
    return CursorSpace[ P ].Next == 0;
}

Position Header( List L )
{
    return L;
}

Position First( List L )
{
    return CursorSpace[ L ].Next;
}

Position Find( ElementType X, List L )
{
    Position P;
    
    if ( IsEmpty( L ) )
    {
       printf( "No Data!!!
" );
       exit( 1 );
    }
    else
    {
       P = First( L );
       while ( P != 0 && CursorSpace[ P ].Element != X )
           P = Advance( P );
        
        return P;
    }
}

Position FindPrevious( ElementType X, List L )
{
    Position P;
    
    if ( IsEmpty( L ) )
    {
       printf( "No Data!!!
" );
       exit( 1 );
    }
    else
    {
        P = Header( L );
        while ( Advance( P ) != 0 && Retrieve( Advance( P ) ) != X )
            P = Advance( P );
        
        return P;     //当P为尾部时说明没有找到目标元素 
    }
}

void Delete( ElementType X, List L )
{
    Position TheNode;
    Position LastNode;
    
    LastNode = FindPrevious( X, L );
    if ( ! IsLast( LastNode ) )  //找到目标元素执行删除操作 
    {
       TheNode = CursorSpace[ LastNode ].Next;
    
       CursorSpace[ LastNode ].Next = CursorSpace[ TheNode ].Next;
       CursorFree( TheNode );
    }
}

void DeleteList( List L )
{
    Position P;
    Position Temp;
    
    P = CursorSpace[ L ].Next;
    CursorSpace[ L ].Next = 0;
    
    while ( P != 0 )
    {
        Temp = Advance( P );
        CursorFree( P );
        P = Temp;
    }
}

void Insert( ElementType X, List L, Position P )
{
    Position NewNode;
    
    NewNode = CursorAlloc();
    if ( NewNode == 0 )
    {
       printf( "No Space!!!
" );
       exit( 1 );
    }
    CursorSpace[ NewNode ].Element = X;
    
    CursorSpace[ NewNode ].Next = CursorSpace[ P ].Next;
    CursorSpace[ P ].Next = NewNode;
}

Position Advance( Position P )
{
    return CursorSpace[ P ].Next;
}

ElementType Retrieve( Position P )
{
    return CursorSpace[ P ].Element;
}

void PrintfList( List L )
{
    Position P;
    
    P = First( L );
    while ( P != 0 )
    {
        printf( "%3d", CursorSpace[ P ].Element );
        P = Advance( P );
    }
    printf( "
" );
}

/*申请内存*/
static Position CursorAlloc( void )
{
    Position P;
    
    P = CursorSpace[ 0 ].Next;
    CursorSpace[ 0 ].Next = CursorSpace[ P ].Next;
    
    return P;
}

/*释放内存*/
static void CursorFree( Position P )
{
    CursorSpace[ P ].Next = CursorSpace[ 0 ].Next;
    CursorSpace[ 0 ].Next = P;
}