纯c语言通用链表

纯c语言通用链表

概述

c语言标准库不存在链表, 所以为了数据的简单操作自己写了一份链表

代码

############               general_list.h             ##############

#ifndef __GENERAL_LIST_H__
#define __GENERAL_LIST_H__


#ifdef __cplusplus
extern "C"
{
#endif


/*
    * 宏定义通用节点结构体
*/
typedef struct GeneralNode
{
    void* data;
    struct GeneralNode *next;
}GeneralNode;


/*
    * 宏定义通用链表结构体
*/
typedef struct GeneralList
{
    GeneralNode* first;
    GeneralNode* last;
    int count;
} GeneralList;


/*
    * 宏定义通用迭代器结构体
*/
typedef struct myListIterator
{
    GeneralNode* p;
    int count;
    int allSize;
} GeneralListIterator;


/*
    * 功能:  创建链表
    * 返回值, 成功返回链表指针,失败返回NULL
*/
GeneralList* createGeneralList();

/*
    * 功能:  释放链表
    * 参数1: 需要操作的链表
    * 返回值, 无
*/
void freeGeneralList(GeneralList* pGeneralList);

/*
    * 功能:  释放链表,保留表头
    * 参数1: 需要操作的链表
    * 返回值, 无
*/
void freeGeneralListSaveHead(GeneralList* pGeneralList);

/*
    * 功能:  尾部插入链表
    * 参数1: 需要操作的链表
    * 参数2: 插入的数据
    * 参数3: 数据大小
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListInsertDataAtLast(GeneralList * const pGeneralList, void* const pData, const int nSize);

/*
    * 功能:  首部插入链表
    * 参数1: 需要操作的链表
    * 参数2: 插入的数据
    * 参数3: 数据大小
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListInsertDataAtFirst(GeneralList * const pGeneralList, void* const pData, const int nSize);

/*
    * 功能:  获取链表长度
    * 参数1: 需要操作的链表
    * 返回值, 链表的长度, >=0表示成功, <0表示失败
*/
int generalListGetSize(const GeneralList * const pGeneralList);

/*
    * 功能:  输出链表
    * 参数1: 需要操作的链表
    * 参数2: 输出回调函数
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListOutput(const GeneralList * const pGeneralList, void(*pt)(const void* const));

/*
    * 功能:  删除链表首部节点
    * 参数1: 需要操作的链表
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListRemoveDataAtFirst(GeneralList * const pGeneralList);

/*
    * 功能:  删除链表尾部节点
    * 参数1: 需要操作的链表
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListRemoveDataAtLast(GeneralList* const pGeneralList);

/*
    * 功能:  链表插入节点
    * 参数1: 需要操作的链表
    * 参数2: 插入的数据
    * 参数3: 数据大小
    * 参数3: 需要插入的位置(在某个元素之后,0表示表头)
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListInsertDataAt(GeneralList* const pGeneralList, void* const pData, const int nSize, const int nIndex);

/*
    * 功能:  删除链表某个节点
    * 参数1: 需要操作的链表
    * 参数2: 需要删除的位置(>0)
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListRemoveDataAt(GeneralList* const pGeneralList, const int nIndex);

/*
    * 功能:  获取链表第一个节点
    * 参数1: 需要操作的链表
    * 返回值, 链表的节点
*/
void* generalListGetDataAtFirst(const GeneralList * const pGeneralList);

/*
    * 功能:  获取链表最后一个节点
    * 参数1: 需要操作的链表
    * 返回值, 链表的节点
*/
void* generalListGetDataAtLast(const GeneralList * const pGeneralList);

/*
    * 功能:  获取链表某个节点
    * 参数1: 需要操作的链表
    * 参数2: 需要获取节点的位置(>0)
    * 返回值, 链表的节点
*/
void* generalListGetDataAt(const GeneralList* const pGeneralList, const int nIndex);

/*
    * 功能:  创建迭代器
    * 参数1: 需要操作的链表
    * 返回值, 迭代器
*/
GeneralListIterator* createGeneralListIterator(const GeneralList * const pGeneralList);

/*
    * 功能:  释放迭代器
    * 参数1: 需要操作的迭代器
    * 返回值, 无
*/
void freeGeneralListIterator(GeneralListIterator* pIterator);

/*
    * 功能:  判断迭代器是否还有下个元素
    * 参数1: 需要操作的迭代器
    * 返回值, 返回迭代器还存在节点个数
*/
int generalListIteratorHasNext(const GeneralListIterator* const pIterator);

/*
    * 功能:  返回迭代器下个元素
    * 参数1: 需要操作的迭代器
    * 返回值, 返回迭代器下个元素
*/
void* generalListIteratorNext(GeneralListIterator* const pIterator);






#ifdef __cplusplus
}
#endif

#endif /*__GENERAL_LIST_H__*/

##########        general_list.c       ##############

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include "general_list.h"


/*
    * 功能:  创建链表
    * 返回值, 成功返回链表指针,失败返回NULL
*/
GeneralList* createGeneralList()
{
    GeneralList* pGeneralList = (GeneralList*) malloc(sizeof(GeneralList));
    if(NULL == pGeneralList)
    {
        printf("createGeneralList malloc list memory error!\n");
        return NULL;
    }

    pGeneralList->count = 0;
    pGeneralList->first = NULL;
    pGeneralList->last  = NULL;
    return pGeneralList;
}


/*
    * 功能:  释放链表
    * 参数1: 需要操作的链表
    * 返回值, 无
*/
void freeGeneralList(GeneralList* pGeneralList)
{
    //参数合法性检查
    if(NULL == pGeneralList)
    {
        return;
    }

    GeneralNode* p = NULL;
    while (NULL != pGeneralList->first)
    {
        p = pGeneralList->first->next;
        free(pGeneralList->first);
        pGeneralList->first = p;
    }
    free(pGeneralList);

    return;
}


/*
    * 功能:  释放链表,保留表头
    * 参数1: 需要操作的链表
    * 返回值, 无
*/
void freeGeneralListSaveHead(GeneralList* pGeneralList)
{
    //参数合法性检查
    if(NULL == pGeneralList)
    {
        return;
    }

    GeneralNode* p = NULL;
    while (NULL != pGeneralList->first)
    {
        p = pGeneralList->first->next;
        free(pGeneralList->first);
        pGeneralList->first = p;
    }

    //清空表头
    pGeneralList->count = 0;
    pGeneralList->first = NULL;
    pGeneralList->last  = NULL;

    return;
}



/*
    * 功能:  尾部插入链表
    * 参数1: 需要操作的链表
    * 参数2: 插入的数据
    * 参数3: 数据大小
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListInsertDataAtLast(GeneralList * const pGeneralList, void* const pData, const int nSize)
{
    //参数合法性检查
    if(NULL == pGeneralList || 0 > nSize)
    {
        printf("generalListInsertDataAtLast pGenerallist is null or nSize(%d) error!\n", nSize);
        return -1;
    }

    //创建数据
    void* data = NULL;
    if(0 < nSize && NULL != pData)
    {
        data = (void*) malloc(nSize);
        if(NULL == data)
        {
            printf("generalListInsertDataAtLast malloc data memory error!\n");
            return -1;
        }
        memcpy(data, pData, nSize);
    }

    //创建节点
    GeneralNode* node = (GeneralNode*) malloc(sizeof(GeneralNode));
    if(NULL == node)
    {
        printf("generalListInsertDataAtLast malloc node memory error!\n");
        free(data);
        return -1;
    }

    node->data = data;
    node->next = NULL;
    if(0 < pGeneralList->count)
    {

        pGeneralList->last->next = node;
        pGeneralList->last       = node;
    }
    else
    {
        pGeneralList->first = node;
        pGeneralList->last  = node;
    }
    (pGeneralList->count)++;

    return 0;
}


/*
    * 功能:  首部插入链表
    * 参数1: 需要操作的链表
    * 参数2: 插入的数据
    * 参数3: 数据大小
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListInsertDataAtFirst(GeneralList * const pGeneralList, void* const pData, const int nSize)
{

    //参数合法性检查
    if(NULL == pGeneralList || 0 > nSize)
    {
        printf("generalListInsertDataAtFirst pGenerallist is null or nSize(%d) error!\n", nSize);
        return -1;
    }

    //创建数据
    void* data = NULL;
    if(0 < nSize && NULL != pData)
    {
        data = (void*) malloc(nSize);
        if(NULL == data)
        {
            printf("generalListInsertDataAtFirst malloc data memory error!\n");
            return -1;
        }
        memcpy(data, pData, nSize);
    }

    GeneralNode* node = (GeneralNode*) malloc(sizeof(GeneralNode));
    if(NULL == node)
    {
        printf("generalListInsertDataAtFirst malloc node memory error!\n");
        free(data);
        return -1;
    }

    node->data = data;
    node->next = NULL;

    if (0 < pGeneralList->count)
    {
        node->next = pGeneralList->first;
        pGeneralList->first = node;
    }
    else
    {
        pGeneralList->first = node;
        pGeneralList->last  = node;
    }
    (pGeneralList->count)++;

    return 0;
}


/*
    * 功能:  获取链表长度
    * 参数1: 需要操作的链表
    * 返回值, 链表的长度, >=0表示成功, <0表示失败
*/
int generalListGetSize(const GeneralList * const pGeneralList)
{
    //参数合法性检查
    if(NULL == pGeneralList)
    {
        printf("generalListGetSize pGenerallist is null!\n");
        return -1;
    }

    return pGeneralList->count;
}


/*
    * 功能:  输出链表
    * 参数1: 需要操作的链表
    * 参数2: 输出回调函数
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListOutput(const GeneralList * const pGeneralList, void(*pt)(const void* const))
{
    //参数合法性检查
    if(NULL == pGeneralList)
    {
        printf("generalListOutput pGenerallist is null!\n");
        return -1;
    }

    GeneralNode* p = pGeneralList->first;
    while (NULL != p)
    {
        (*pt)(p->data);
        p = p->next;
    }

    return 0;
}


/*
    * 功能:  删除链表首部节点
    * 参数1: 需要操作的链表
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListRemoveDataAtFirst(GeneralList * const pGeneralList)
{
    //参数合法性检查
    if(NULL == pGeneralList)
    {
        printf("generalListRemoveDataAtFirst pGenerallist is null!\n");
        return -1;
    }

    GeneralNode* p = pGeneralList->first;
    if(NULL == p)
    {
        //链表为空
        return 0;
    }

    pGeneralList->first = p->next;
    void* re = p->data;
    free(p);
    (pGeneralList->count)--;
    if (pGeneralList->count == 0)
    {
        pGeneralList->last = NULL;
    }

    //释放数据
    free(re);
    re = NULL;

    return 0;
}


/*
    * 功能:  删除链表尾部节点
    * 参数1: 需要操作的链表
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListRemoveDataAtLast(GeneralList* const pGeneralList)
{
    //参数合法性检查
    if(NULL == pGeneralList)
    {
        printf("generalListRemoveDataAtLast pGenerallist is null!\n");
        return -1;
    }

    if(0 == pGeneralList->count)
    {   //链表为空
        return 0;
    }
    else if(1 == pGeneralList->count)
    {
        //链表只有一个节点
        return generalListRemoveDataAtFirst(pGeneralList);
    }
    else
    {
        //链表存在多个节点
        GeneralNode* p = pGeneralList->first;
        if(NULL == p)
        {
            printf("generalListRemoveDataAtLast list exists error!\n");
            return -1;
        }

        //找到尾部的前一个节点
        while (p->next != pGeneralList->last)
        {
            p = p->next;
        }

        void *re = pGeneralList->last->data;
        free(pGeneralList->last);
        p->next = NULL;
        pGeneralList->last = p;
        (pGeneralList->count)--;

        //释放数据
        free(re);
        re = NULL;

        return 0;
    }
}


/*
    * 功能:  链表插入节点
    * 参数1: 需要操作的链表
    * 参数2: 插入的数据
    * 参数3: 数据大小
    * 参数3: 需要插入的位置(在某个元素之后,0表示表头)
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListInsertDataAt(GeneralList* const pGeneralList, void* const pData, const int nSize, const int nIndex)
{
    //参数合法性检查
    if(NULL == pGeneralList || 0 > nSize)
    {
        printf("generalListInsertDataAt pGenerallist is null or nSize(%d) error!\n", nSize);
        return -1;
    }

    if(0 > nIndex || pGeneralList->count < nIndex)
    {
        printf("generalListInsertDataAt insert index(%d) or max index(%d) error!\n", nIndex, pGeneralList->count);
        return -1;
    }

    if (0 == nIndex)
    {
        //插入表头
        return generalListInsertDataAtFirst(pGeneralList, pData, nSize);
    }
    else if (nIndex == pGeneralList->count)
    {
        //插入表尾
        return generalListInsertDataAtLast(pGeneralList, pData, nSize);
    }
    else
    {
        //存在至少一个节点

        //创建数据
        void* data = NULL;
        if(0 < nSize && NULL != pData)
        {
            data = (void*) malloc(nSize);
            if(NULL == data)
            {
                printf("generalListInsertDataAt malloc data memory error!\n");
                return -1;
            }
            memcpy(data, pData, nSize);
        }

        GeneralNode* node = (GeneralNode*) malloc(sizeof(GeneralNode));
        if(NULL == node)
        {
            printf("generalListInsertDataAt malloc node memory error!\n");
            free(data);
            return -1;
        }

        node->data = data;
        node->next = NULL;

        GeneralNode* p = pGeneralList->first;
        if(NULL == p)
        {
            printf("generalListInsertDataAt list exists error!\n");
            free(data);
            free(node);
            return -1;
        }

        //找到插入节点(插入数据在这个节点之后)
        int i = 0;
        for (; i < nIndex - 1; i++)
        {
            p = p->next;
            if(NULL == p)
            {
                printf("generalListInsertDataAt list exists error!\n");
                free(data);
                free(node);
                return -1;
            }
        }
        node->next = p->next;
        p->next = node;

        (pGeneralList->count)++;
        return 0;
    }
}


/*
    * 功能:  删除链表某个节点
    * 参数1: 需要操作的链表
    * 参数2: 需要删除的位置(>0)
    * 返回值, >=0表示成功, <0表示失败
*/
int generalListRemoveDataAt(GeneralList* const pGeneralList, const int nIndex)
{
    //参数合法性检查
    if(NULL == pGeneralList)
    {
        printf("generalListRemoveDataAt pGenerallist is null!\n");
        return -1;
    }

    if(0 >= nIndex || pGeneralList->count < nIndex)
    {
        printf("generalListRemoveDataAt remove index(%d) or max index(%d) error!\n", nIndex, pGeneralList->count);
        return -1;
    }

    if(1 == nIndex)
    {
        //删除首节点
        return generalListRemoveDataAtFirst(pGeneralList);
    }
    else if (nIndex == pGeneralList->count)
    {
        //删除尾节点
        return generalListRemoveDataAtLast(pGeneralList);
    }
    else
    {
        //存在多个节点,删除中间节点
        GeneralNode * p = pGeneralList->first;
        if(NULL == p)
        {
            printf("generalListRemoveDataAt list exists error!\n");
            return -1;
        }

        //找到删除前面一个节点
        int i = 0;
        for (; i < nIndex - 2; i++)
        {
            p = p->next;
            if(NULL == p)
            {
                printf("generalListRemoveDataAt list exists error!\n");
                return -1;
            }
        }

        //需要删除的节点
        GeneralNode* tp = p->next;
        if(NULL == tp)
        {
            printf("generalListRemoveDataAt list exists error!\n");
            return -1;
        }

        p->next = p->next->next;
        void* re = tp->data;
        free(tp);
        (pGeneralList->count)--;

        //释放节点
        free(re);
        re = NULL;

        return 0;
    }

}


/*
    * 功能:  获取链表第一个节点
    * 参数1: 需要操作的链表
    * 返回值, 链表的节点
*/
void* generalListGetDataAtFirst(const GeneralList * const pGeneralList)
{
    //参数合法性检查
    if(NULL == pGeneralList)
    {
        printf("generalListGetDataAtFirst pGenerallist is null!\n");
        return NULL;
    }

    return pGeneralList->first->data;
}


/*
    * 功能:  获取链表最后一个节点
    * 参数1: 需要操作的链表
    * 返回值, 链表的节点
*/
void* generalListGetDataAtLast(const GeneralList * const pGeneralList)
{
    //参数合法性检查
    if(NULL == pGeneralList)
    {
        printf("generalListGetDataAtLast pGenerallist is null!\n");
        return NULL;
    }

    return pGeneralList->last->data;
}


/*
    * 功能:  获取链表某个节点
    * 参数1: 需要操作的链表
    * 参数2: 需要获取节点的位置(>0)
    * 返回值, 链表的节点
*/
void* generalListGetDataAt(const GeneralList* const pGeneralList, const int nIndex)
{
    //参数合法性检查
    if(NULL == pGeneralList)
    {
        printf("generalListGetDataAt pGenerallist is null!\n");
        return NULL;
    }

    if(0 >= nIndex || pGeneralList->count < nIndex)
    {
        printf("generalListGetDataAt get index(%d) or max index(%d) error!\n", nIndex, pGeneralList->count);
        return NULL;
    }

    if(1 == nIndex)
    {
        //首节点
        return generalListGetDataAtFirst(pGeneralList);
    }
    if(nIndex == pGeneralList->count)
    {
        //尾节点
        return generalListGetDataAtLast(pGeneralList);
    }
    else
    {
        //中间节点
        GeneralNode* p = pGeneralList->first;
        if(NULL == p)
        {
            printf("generalListGetDataAt list exists error!\n");
            return NULL;
        }

        //找到获取的节点
        int i = 0;
        for (; i < nIndex - 1; i++)
        {
            p = p->next;
            if(NULL == p)
            {
                printf("generalListGetDataAt list exists error!\n");
                return NULL;
            }
        }

        return p->data;
    }

}


/*
    * 功能:  创建迭代器
    * 参数1: 需要操作的链表
    * 返回值, 迭代器
*/
GeneralListIterator* createGeneralListIterator(const GeneralList * const pGeneralList)
{
    //参数合法性检查
    if(NULL == pGeneralList)
    {
        printf("createGeneralListIterator pGenerallist is null!\n");
        return NULL;
    }

    GeneralListIterator* re = (GeneralListIterator*) malloc(sizeof(GeneralListIterator));
    if(NULL == re)
    {
        printf("createGeneralListIterator malloc iterator memory error!\n");
        return NULL;
    }

    re->p       = pGeneralList->first;
    re->allSize = pGeneralList->count;
    re->count   = 0;

    return re;
}


/*
    * 功能:  释放迭代器
    * 参数1: 需要操作的迭代器
    * 返回值, 无
*/
void freeGeneralListIterator(GeneralListIterator* pIterator)
{
    free(pIterator);
}


/*
    * 功能:  判断迭代器是否还有下个元素
    * 参数1: 需要操作的迭代器
    * 返回值, 返回迭代器还存在节点个数
*/
int generalListIteratorHasNext(const GeneralListIterator* const pIterator)
{
    //参数合法性检查
    if(NULL == pIterator)
    {
        printf("generalListIteratorHasNext pIterator is null!\n");
        return -1;
    }

    return (pIterator->allSize) - (pIterator->count);
}


/*
    * 功能:  返回迭代器下个元素
    * 参数1: 需要操作的迭代器
    * 返回值, 返回迭代器下个元素
*/
void* generalListIteratorNext(GeneralListIterator* const pIterator)
{
    //参数合法性检查
    if(NULL == pIterator)
    {
        printf("generalListIteratorNext pIterator is null!\n");
        return NULL;
    }

    if(NULL == pIterator->p)
    {
        printf("generalListIteratorNext node is null!\n");
        return NULL;
    }

    void* re = pIterator->p->data;
    pIterator->p = pIterator->p->next;
    (pIterator->count)++;

    return re;
}

##########        main.c     #############

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include "general_list.h"


typedef struct TEST
{  
    int i;  
    char c;  
} TEST;  
  
void callbackOutput(const void* const p)  
{  
    if(NULL != p)
	{
		TEST * pTest= (TEST*)p;  
		printf("i: %d   c: (%c)\n", pTest->i, pTest->c);  
	}
}


int main()
{

    //创建链表  
    GeneralList* list= createGeneralList();
    if(NULL == list)
    {
        printf("create list failure!\n");
        return 0;
    }
  
    //测试三种插入方法
	TEST test1;
	test1.c = 'A';
	test1.i = 65;
    generalListInsertDataAtLast(list, &test1, sizeof(TEST));
	//输出  
    generalListOutput(list, callbackOutput);  

    TEST test2;
	test2.c = 'B';
	test2.i = 66;
    generalListInsertDataAtFirst(list, &test2, sizeof(TEST));
	//输出  
    generalListOutput(list, callbackOutput);
    
    TEST test3;
	test3.c = 'C';
	test3.i = 67;
    generalListInsertDataAt(list, &test3, sizeof(TEST), 2);
	//输出  
    generalListOutput(list, callbackOutput);
    
	printf("!!!!!!!!!!!!!!!!!!\n");

    //测试迭代器遍历输出
	GeneralListIterator * it = createGeneralListIterator(list); 
    if(NULL == list)
    {
        printf("create iterator failure!\n");
        //释放链表  
        freeGeneralList(list); 
        return 0;
    }
    
    while(0 < generalListIteratorHasNext(it))  
    {  
        TEST* pTest = (TEST*)generalListIteratorNext(it);
		if(NULL == pTest)
        {
            break;
        }
        else
		{
            printf("i: %d   c: (%c)\n", pTest->i, pTest->c);  
		}
    }

    //释放迭代器  
    freeGeneralListIterator(it);  
  
    //释放链表  
    freeGeneralList(list);  

    return 0; 

}