C语言 线性表 链式表结构 实现

一个单链式实现的线性表 mList (GCC编译)。

/**
* @brief 线性表的链式实现 (单链表)
* @author wid
* @date 2013-10-21
*
* @note 若代码存在 bug 或程序缺陷, 请留言反馈, 谢谢!
*/

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

#define TRUE 1
#define FALSE 0

typedef struct
{
    int x;
    int y;
}Point2D;   //Point2D 结构
typedef Point2D ElemType;       //声明 Point2D 结构的别名 ElemType

typedef struct LNode
{
    Point2D pt;
    struct LNode *next;
}ListNode;          //线性表数据项结构

typedef struct
{
    ListNode *head;     //数据项头节点
    int length;         //线性表长度
}mList;         //线性表 mList 结构


//线性表方法声明
mList *CreateList();        ///创建一个空的线性表
void DestroyList( mList *pList );   ///销毁一条线性表
void ClearList( mList *pList );     ///置空一条线性表
int GetLength( mList *pList );      ///获取线性表当前长度
int IsEmpty( mList *pList );        ///检测线性表是否为空
int AppendElem( mList *pList, ElemType *pt );            ///向线性表末尾添加一个元素
int InsertElem( mList *pList, int nPos, ElemType *pt );  ///向线性表中插入一个元素
int DeleteElem( mList *pList, int nPos );                ///从线性表中删除一个元素
int GetElem( mList *pList, int nPos, ElemType *pt );     ///获取线性表中某位置上的元素
int FindElem( mList *pList, int nPos, ElemType *pt );    ///从某位置起查找某元素在线性表中第一次出现的位置
int GetPriorElem( mList *pList, ElemType *pt, ElemType *prior_pt );     ///从线性表中获取 pt 的前驱节点到 prior_pt
int GetNextElem( mList *pList, ElemType *pt, ElemType *next_pt );       ///从线性表中获取 pt 的后继节点到 next_pt
void ForEachList( mList *pList, void (*func)(ElemType *pt) );           ///对线性表中每个元素执行 func 函数
int ListCpy( mList *pDestList, mList *pSrcList );        ///将一线性表复制到另一线性表后
int ListCat( mList *pDestList, mList *pSrcList );        ///将一线性表连接到另一线性表后


//线性表方法实现

/**
* @brief 创建一个空的线性表
*
* @return 指向创建的线性表的指针
*/
mList *CreateList()
{
    mList *pList = (mList *)malloc(sizeof(mList));
    pList->head = (ListNode *)malloc(sizeof(ListNode));
    pList->head->next = NULL;
    pList->length = 0;

    return pList;
}

/**
* @brief 销毁一条线性表
*
* @param 指向待销毁的线性表的指针
*
* @return void
*/
void DestroyList( mList *pList )
{
    ListNode *pm = pList->head, *pn = NULL;
    while( pm != NULL )
    {
        pn = pm->next;
        free(pm);
        pm = pn;
    }
    free(pList);
    pList = NULL;
}

/**
* @brief 置空一条线性表
*
* @param 指向待置空的线性表指针
*
* @return void
*/
void ClearList( mList *pList )
{
    ListNode *pm = pList->head, *pn = NULL;
    while( pm != NULL )
    {
        pn = pm->next;
        free(pm);
        pm = pn;
    }
    pList->head->next = NULL;
    pList->length = 0;
}

/**
* @brief 获取线性表当前长度
*
* @param 指针待获取长度的线性表的指针
*
* @return 返回获取到的线性表长度
*/
int GetLength( mList *pList )
{
    return pList->length;
}

/**
* @brief 检测线性表是否为空
*
* @param pList 指向待检测的线性表的指针
*
* @return 若为空则返回 TRUE, 否则返回 FALSE
*/
int IsEmpty( mList *pList )
{
    return pList->length == 0 ? TRUE : FALSE;
}

/**
* @brief 向线性表末尾添加一个元素
*
* @param pList 目标线性表
* @param pe 指向待添加元素的指针
*
* @return 返回添加成功后当前线性表长度
*/
int AppendElem( mList *pList, ElemType *pt )
{
    ListNode *pm = pList->head, *pn = NULL;

    while( pm->next != NULL ) { pm = pm->next; };
    pn = (ListNode *)malloc(sizeof(ListNode));
    pn->pt.x = pt->x;
    pn->pt.y = pt->y;
    pn->next = NULL;
    pm->next = pn;

    return ++pList->length;
}

/**
* @brief 向线性表中插入一个元素
*
* @param pList 指向待插入元素的线性表
* @param nPos 插入的位置
* @param pt 指向待插入的元素的指针
*
* @return 若插入成功则返回插入后线性表当前长度, 否则返回 -1
*
* @note 插入位置 nPos 从 0 计起
*/
int InsertElem( mList *pList, int nPos, ElemType *pt )
{
    ListNode *pm = pList->head, *pn = NULL;

    if( nPos < 0 || nPos > pList->length - 1 )         ///插入位置是否在线性表内
        return -1;

    int n = 0;
    for( n = 0; n < nPos; ++n, (pm = pm->next) );
    pn = (ListNode *)malloc(sizeof(ListNode));
    pn->pt.x = pt->x;
    pn->pt.y = pt->y;

    pn->next = pm->next;
    pm->next = pn;

    return ++pList->length;
}

/**
* @brief 从线性表中删除一个元素
*
* @param pList 指向待删除元素的线性表指针
* @param nPos 待删除元素的位置
*
* @return 若删除成功则返回删除后线性表当前长度, 否则返回 -1
*
* @note 删除位置 nPos 从 0 计起
*/
int DeleteElem( mList *pList, int nPos )
{
    ListNode *pm = pList->head, *pn = NULL;

    if( nPos < 0 || nPos > pList->length - 1 )         ///删除位置是否在线性表内
        return -1;

    int i = 0;
    for( i = 0; i < nPos; ++i, (pm = pm->next) );
    pn = pm->next;
    pm->next = pn->next;
    free(pn);

    return --pList->length;
}

/**
* @brief 获取线性表中某位置上的元素
*
* @param pList 指向待获取元素的线性表指针
* @param nPos 元素在线性表中的位置
* @param pt 指向存放获取到的元素的指针
*
* @return 若获取成功, 返回 TRUE, 否则返回 FALSE
*
* @note 元素位置从 0 计起
*/
int GetElem( mList *pList, int nPos, ElemType *pt )
{
    int n = nPos;
    if( n < 0 || n > pList->length - 1 )
        return FALSE;

    ListNode *pm = pList->head;
    for( n = 0; n <= nPos; ++n, (pm = pm->next) );
    pt->x = pm->pt.x;
    pt->y = pm->pt.y;

    return TRUE;
}

/**
* @brief 从某位置起查找某元素在线性表中第一次出现的位置
*
* @param pList 指向待查找元素的线性表的指针
* @param nPos 查找起始位置
* @param pt 指向待查找的元素的指针
*
* @return 若找到, 则返回元素所在的位置, 否则返回 -1
*
* @note 起始位置由 0 计起
*/
int FindElem( mList *pList, int nPos, ElemType *pt )
{
    int n = nPos;
    if( n < 0 || n > pList->length - 1 )
        return -1;

    ListNode *pm = pList->head;
    for( n = 0; n <= nPos; ++n, (pm = pm->next) );
    for( ; pm != NULL; ++n )
    {
        if( (pm->pt.x == pt->x) && (pm->pt.y == pt->y) )
            return n-1;

        pm = pm->next;
    }

    return -1;
}

/**
* @brief 获取某 pt 元素的前驱节点到 prior_pt
*
* @param 指向待获取前驱节点的线性表指针
* @param pt 指向目标节点的指针
* @param prior_pt 存放目标节点 pt 的前驱节点
*
* @return 若成功获取前驱节点, 返回该前驱节点在线性表中的位置, 否则返回 -1
*
* @note 元素位置从 0 计起
*/
int GetPriorElem( mList *pList, ElemType *pt, ElemType *prior_pt )
{
    ListNode *pm = pList->head;
    int ncnt = 0;
    while( pm->next != NULL )
    {
        if( pm->next->pt.x == pt->x && pm->next->pt.y == pt->y )
        {
            if( ncnt != 0 )         ///不为首节点
            {
                prior_pt->x = pm->pt.x;
                prior_pt->y = pm->pt.y;
                return ncnt - 1;
            }
            else return -1;      ///不存在前驱节点
        }
        pm = pm->next;
        ++ncnt;
    }

    return -1;
}

/**
* @brief 获取某 pt 元素的后继节点到 next_pt
*
* @param 指向待获取前后继点的线性表指针
* @param pt 指向目标节点的指针
* @param prior_pt 存放目标节点 pt 的后继节点
*
* @return 若成功获取后继节点, 返回该后继节点在线性表中的位置, 否则返回 -1
*
* @note 元素位置从 0 计起
*/
int GetNextElem( mList *pList, ElemType *pt, ElemType *next_pt )
{
    ListNode *pm = pList->head;
    int ncnt = 0;
    while( (pm = pm->next) != NULL )
    {
　　　　　　　if( ncnt == pList->length )　　//bug修复, 不存在后继节点
　　　　　　　　　　return -1;

        if( pm->pt.x == pt->x && pm->pt.y == pt->y )
        {
            if( pm->next != NULL )
            {
                next_pt->x = pm->next->pt.x;
                next_pt->y = pm->next->pt.y;

                return ncnt + 1;
            }
        }
        ++ncnt;
    }

    return -1;
}

/**
* @brief 对线性表中每个元素执行 func 函数
*
* @param pList 指向待处理的线性表的指针
* @param func 传入的函数指针
*
* @return void
*/
void ForEachList( mList *pList, void (*func)(ElemType *pt) )
{
    ListNode *pm = pList->head;
    while( (pm = pm->next) != NULL )
        func( &pm->pt );
}

/**
* @brief 将 pSrcList 性表复制到 pDestList 线性表后
*
* @param pDestList 指向目标线性表指针
* @param pSrcList 指向源线性表指针
*
* @return 返回复制后目标线性表长度
*/
int ListCpy( mList *pDestList, mList *pSrcList )
{
    ListNode *pm = pDestList->head;
    ListNode *pn = pSrcList->head;
    ListNode *ptmp = NULL;

    while( pm->next != NULL ) pm = pm->next;
    while( (pn = pn->next) != NULL )
    {
        ptmp = (ListNode *)malloc(sizeof(ListNode));
        ptmp->pt.x = pn->pt.x;
        ptmp->pt.y = pn->pt.y;
        pm->next = ptmp;
        pm = pm->next;
    }
    pm->next = NULL;
    pDestList->length += pSrcList->length;

    return pDestList->length;
}

/**
* @brief 将 pSrcList 性表连接到 pDestList 线性表后
*
* @param pDestList 指向目标线性表指针
* @param pSrcList 指向源线性表指针
*
* @return 返回连接后目标线性表长度
*
* @note 连接后 pSrcList 线性表将被销毁
*/
int ListCat( mList *pDestList, mList *pSrcList )
{
    ListNode *pm = pDestList->head;
    while( pm->next != NULL ) pm = pm->next;
    pm->next = pSrcList->head->next;
    pDestList->length += pSrcList->length;
    free( pSrcList );

    return pDestList->length;
}

//测试 mList

void display( ElemType *pt )
{
    printf("(%d,%d) ", pt->x, pt->y);
}

int main()
{
    mList *plstA = CreateList(), *plstB = CreateList();      //创建 plst 与 plst2 两根空线性表
    ElemType pt, pt2;       //两个 ElemType 型元素

    int i = 0;
    for( i = 0; i < 10; ++i )
    {
        pt.x = i;
        pt.y = i;
        AppendElem( plstA, &pt );    //向 plst 循环添加 (0,0) 至 (10,10)
    }

    for( i = 55; i < 60; ++i )
    {
        pt.x = i;
        pt.y = i;
        AppendElem( plstB, &pt );    //向 plst 循环添加 (55,55) 至 (60,60)
    }

    ///测试 ForEachList
    printf("plstA 初始数据: ");
    ForEachList( plstA, display );   //对线性表中每个元素执行 display 函数

    printf("
plstB 初始数据: ");
    ForEachList( plstB, display );

    ///测试 InsertElem
    printf("

向 plstA 位置3处插入元素(100,99)后:
");
    pt.x = 100; pt.y = 99;
    InsertElem( plstA, 3, &pt );     //向 plstA 位置 3 处插入 pt
    ForEachList( plstA, display );

    ///测试 DeleteElem
    printf("

删除 plstB 位置0处的元素后:
");
    DeleteElem( plstB, 0 );          //删除 plstA 位置 0 处的元素
    ForEachList( plstB, display );

    ///测试 IsEmpty、GetLength
    printf("

线性表 plstA 是否为空: %d
", IsEmpty(plstA) );
    printf("线性表 plstB 的长度: %d
", GetLength(plstB) );

    ///测试 GetElem
    GetElem( plstA, 5, &pt );
    printf("获取 plstA 位置 5 的元素: (%d, %d)
", pt.x, pt.y );

    ///测试 FindElem
    pt.x = 6; pt.y = 6;
    printf("获取元素(6,6)在线性表plstA中的位置: %d
", FindElem(plstA, 0, &pt));

    ///测试 GetPriorElem
    GetPriorElem( plstA, &pt, &pt2 );
    printf("获取pt=(6,6)在plstA中的前驱节点: (%d,%d)
", pt2.x, pt2.y);

    ///测试 GetNextElem
    GetNextElem( plstA, &pt, &pt2 );
    printf("获取pt=(6,6)在plstA中的后继节点: (%d,%d)
", pt2.x, pt2.y);

    ///测试 ListCpy
    printf("
将 plstB 复制到 plstA 后:
");
    ListCpy( plstA, plstB );
    ForEachList( plstA, display );
    printf("
plstA长度=%d
", GetLength(plstA));

    ///测试 ListCat
    printf("
将 plstB 连接到 plstA 后:
");
    ListCat( plstA, plstB );
    ForEachList( plstA, display );
    printf("
plstA长度=%d
", GetLength(plstA));

    ///测试 ClearList
    printf("
置空 plstA 线性表:
");
    ClearList(plstA);
    printf("plstA 长度=%d
", GetLength(plstA));

    ///测试 DestroyList
    printf("销毁 plstA..");
    DestroyList(plstA);

    return 0;
}

若代码存在 bug 或程序缺陷, 请留言反馈, 谢谢。