常用数据结构 双向循环链表（二）

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

#define debug_on 1

typedef unsigned int u32;
typedef unsigned char u8;


//链表函数操作返回状态
typedef enum{
    LIST_SUCCESS = 0,
    LIST_ERROR   = 1
}LIST_RET_VALUE;

typedef struct _LIST_NODE{
   struct _LIST_NODE  *pPrev;      /* 指向链表直接前驱结点的指针 */
   struct _LIST_NODE  *pNext;      /* 指向链表直接后继结点的指针 */
    void        *pNodeData;  /* 指向链表数据的指针 */
}T_LIST_NODE;

typedef struct _LIST{
    T_LIST_NODE   *pHead;          /* 指向链表头结点的指针 */
    u32           nodeCount;       /* 链表结点数目 */
    u32           nodeDataSize;    /* 链表结点保存的数据字节数 */
}T_LIST;


typedef struct _LIST_DATA{
    u32           idx;
    char          name[64];
}T_LIST_DATA;


LIST_RET_VALUE createList(T_LIST **ppList, u32 dataSize)
{
    T_LIST_NODE *head;
    T_LIST *list;

    list = (T_LIST*)malloc(sizeof(T_LIST));
    if(list == NULL)
    {
        printf(" create list failed! \n");
        return LIST_ERROR;
    }
    list->nodeDataSize = dataSize;
    list->nodeCount = 0;

    //
    head = (T_LIST_NODE*)malloc(sizeof(T_LIST_NODE)+list->nodeDataSize);
    if(head == NULL)
    {
        printf(" create list node failed! \n");
        free(list);
        list = NULL;

        return LIST_ERROR;
    }
    memset(head,0,sizeof(T_LIST_NODE)+list->nodeDataSize);
    head->pNext = head;
    head->pPrev = head;
    head->pNodeData = (void*)(head + 1);
    list->pHead = head;

    *ppList = list;
    return LIST_SUCCESS;
}

LIST_RET_VALUE createNode(T_LIST_NODE** ppNewNode, u32 nodeDataSize)
{
    T_LIST_NODE* tmpNode;

    tmpNode = (T_LIST_NODE*)malloc(sizeof(T_LIST_NODE)+nodeDataSize);
    if(tmpNode == NULL)
    {
        printf(" create list node failed! \n");
        return LIST_ERROR;
    }
    tmpNode->pNext = NULL;
    tmpNode->pPrev = NULL;
    tmpNode->pNodeData = (void*)(tmpNode + 1);
    memset(tmpNode->pNodeData,0,nodeDataSize);
    *ppNewNode = tmpNode;

    return LIST_SUCCESS;
}

LIST_RET_VALUE createNodeWithData(T_LIST_NODE** ppNewNode, void* pDat, u32 nodeDataSize)
{
    T_LIST_NODE* tmpNode;

    tmpNode = (T_LIST_NODE*)malloc(sizeof(T_LIST_NODE)+nodeDataSize);
    if(tmpNode == NULL)
    {
        printf(" create list node failed! \n");
        return LIST_ERROR;
    }
    tmpNode->pNext = NULL;
    tmpNode->pPrev = NULL;
    tmpNode->pNodeData = (void*)(tmpNode + 1);
    memcpy(tmpNode->pNodeData, pDat, nodeDataSize);
    *ppNewNode = tmpNode;

    return LIST_SUCCESS;
}

LIST_RET_VALUE insertNode(T_LIST_NODE *prev, T_LIST_NODE *newNode)
{
    if(newNode == NULL)
    {
        printf(" insert node is null! \n");
        return LIST_ERROR;
    }
    
    newNode->pPrev = prev;
    newNode->pNext = prev->pNext;
    prev->pNext->pPrev = newNode;
    prev->pNext = newNode;
    
#if debug_on
    T_LIST_DATA* tmp;
    tmp = (T_LIST_DATA*)(newNode->pNodeData);
    printf("   add node: %d [%s] \n",tmp->idx,tmp->name);
#endif
    return LIST_SUCCESS;
}

LIST_RET_VALUE delNode(T_LIST_NODE *delNode)
{
    if(delNode == NULL)
    {
        printf(" del list is null! \n");
        return LIST_ERROR;
    }
    
    delNode->pPrev = delNode->pNext;
    delNode->pNext->pPrev = delNode->pPrev;

#if debug_on
    T_LIST_DATA* tmp;
    tmp = (T_LIST_DATA*)(delNode->pNodeData);
    printf("   del node: %d [%s] \n",tmp->idx,tmp->name);
#endif

    free(delNode);

    return LIST_SUCCESS;
}

static void delAll(T_LIST* list)
{
    T_LIST_NODE* cur;
    T_LIST_NODE* tmp = list->pHead->pNext;

    while(tmp != list->pHead)
    {
        cur = tmp;
        tmp = tmp->pNext;
        delNode(cur);
    }

    list->pHead->pNext = list->pHead;
    list->pHead->pNext = list->pHead;

}
void destroyList(T_LIST* list)
{
    delAll(list);
    free(list);
}
int main(void)
{


T_LIST* my_list;
T_LIST_DATA data = {1, "Hello world"};
T_LIST_NODE* pNode;

u32 nodeDataSize = sizeof(T_LIST_DATA);

createList(&my_list, nodeDataSize);

createNodeWithData(&pNode,(void*)&data, nodeDataSize);
insertNode(my_list->pHead,pNode);

data.idx++;
createNodeWithData(&pNode,(void*)&data, nodeDataSize);
insertNode(my_list->pHead,pNode);

data.idx++;
createNodeWithData(&pNode,(void*)&data, nodeDataSize);
insertNode(my_list->pHead,pNode);

destroyList(my_list);

return 0;
}