[数据结构与算法] : 单向链表

头文件

// filename: list.h
typedef int ElementType;

#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);
void PrintElement(ElementType X);
void TraversList(List L);        // 正序遍历(递归法)
void ReverseTraversList(List L); // 逆序遍历(递归法)
void TraverseL(List L);          // 对于一个庞大的栈递归可能造成越出栈空间, 使用goto消除尾递归
void TraverseL2(List L);         // while循环遍历

#endif

源文件

filename: list.c

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

struct Node
{
    ElementType Element;
    PtrToNode Next;
};

// 创建或者清空链表
List MakeEmpty(List L)
{
    if(L != NULL)
        DeleteList(L);
    else
    {
        L = (List)malloc( sizeof(struct Node) );
        if(L == NULL)
        {
            exit(-1);
        }
        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 = P->Next;
    return P;
}

// 删除, 注意先判断待删除的元素是否在链表中
void Delete(ElementType X, List L)
{
    Position P = FindPrevious(X, L);// 获得待删除元素的前驱

    if( !IsLast(P, L) ) // 如果X的前驱P是最后一个元素, 则表示L中无X
    {
        Position Q = P->Next;
        P->Next = Q->Next;
        free(Q);
    }
}

// 查找前驱, 注意区分Find操作与FindPrevious的区别是P的初始值不同
Position FindPrevious(ElementType X, List L)
{
    Position P;
    P = L;
    while(P->Next != NULL && P->Next->Element != X)
        P = P->Next;
    return P;
}

// 插入, 在P之后插入
void Insert(ElementType X, List L, Position P)
{
    Position TmpCell;
    // 先创建一个新节点
    TmpCell = (List)malloc( sizeof(struct Node) );
    if(TmpCell == NULL)
    {
        exit(-1);
    }

    TmpCell->Element = X;
    TmpCell->Next = P->Next;
    P->Next = TmpCell;
}

// 销毁链表, 需要两个指针
void DeleteList(List L)
{
    Position P, Q;

    P = L->Next; // 重要, 保留头节点
    L->Next = NULL;
    while(P != NULL)
    {
        Q = P->Next;
        free(Q);
        P = Q;
    }
}

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

void PrintElement(ElementType X)
{
    printf("%d ", X);
}

// 递归遍历链表
void TraversList(List L)
{
    if(L != NULL)
    {
        PrintElement(L->Element);
        TraversList(L->Next);
    }
}

// 递归反向打印链表
void ReverseTraversList(List L)
{
    if(L != NULL)
    {
        ReverseTraversList(L->Next);
        PrintElement(L->Element);
    }
}

void TraverseL(List L)
{
    top:
        if(L != NULL)
        {
            PrintElement(L->Element);
            L = L->Next;
            goto top;
        }
}

// 遍历链表, 非递归实现, 推荐
void TraverseL2(List L)
{
    while(L != NULL)
    {
        PrintElement(L->Element);
        L = L->Next;
    }
}

测试文件

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

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( "
" );
    }
}

void TraverseList(const List L)
{
    Position P = Header(L);
    if( IsEmpty(L) )
        printf("链表为空
");
    else
    {
        do
        {
            P = Advance(P);
            printf("%d ", Retrieve(P));
        } while( !IsLast(P, L) );
        printf("
");
    }
}

main( )
{
    List L;
    Position P;
    int i;

    L = MakeEmpty( NULL );
    P = Header( L );
    // TraverseList( L );
    TraverseList(L);

    for( i = 0; i < 10; i++ )
    {
        Insert( i, L, P );
        TraverseList( 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
" );

    TraverseList( L );
    TraversList( Advance(L) );
    printf("
");
    ReverseTraversList( Advance(L) );
    printf("
");
    TraverseL( Advance(L) );
    printf("
");
    TraverseL2( Advance(L) );
    printf("
");

    DeleteList( L );

    return 0;
}