一个优雅的双向链表的实现

// basic_defs.h
#ifndef __BASIC_DEFS_H__
#define __BASIC_DEFS_H__

#include "head.h" // 包含必须的标准库文件

typedef unsigned long long      UINT64_T;
typedef long long               INT64_T;
typedef unsigned int            UINT32_T;
typedef int                     INT32_T;
typedef unsigned short          UINT16_T;
typedef short                   INT16_T;
typedef unsigned char           UINT8_T;
typedef unsigned char           UCHAR_T;
typedef char                    INT8_T;
typedef char                    CHAR_T;
typedef unsigned char           BOOLEAN_T;
typedef float                   FLOAT_T;
typedef double                  DOUBLE_T;
typedef void                    VOID;

#include "error_defs.h" // 错误码定义头文件

#ifndef TRUE
#define TRUE            1
#endif

#ifndef FALSE
#define FALSE           0
#endif

#ifndef NULL
#define NULL            0
#endif

#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))

typedef INT32_T SYS_RET_T;

#endif

// dlink.h
#ifndef __DLINK_H__
#define __DLINK_H__

#include "basic_defs.h"

struct NODE_T
{
INT32_T id;
struct NODE_T *next, *prev;
};

typedef struct NODE_T LINK_NODE_T, LINK_LIST_T, *PLINK_LIST_T;

LINK_NODE_T *linkNode_malloc(INT32_T id);
VOID linkNode_free(LINK_NODE_T **p);
PLINK_LIST_T linkList_init(VOID);
LINK_NODE_T *linkList_find(PLINK_LIST_T head, INT32_T id);
INT32_T linkList_insert(PLINK_LIST_T head, INT32_T id);
INT32_T linkList_delete(PLINK_LIST_T head, INT32_T id);
VOID linkList_print(PLINK_LIST_T head);

#endif

//dlink.c
/* 带头结点的双向链表操作 */
#include "dlink.h"

LINK_NODE_T *linkNode_malloc(INT32_T id)
{
LINK_NODE_T *p = NULL;

p = (LINK_NODE_T *)malloc(sizeof(LINK_NODE_T));
if (p == NULL)
{
printf("Malloc error!\n");
return NULL;
}

p->id = id;
p->next = p->prev = NULL;

return p;
}

VOID linkNode_free(LINK_NODE_T **p)
{
if (*p == NULL)
&nbs
7fe8
p;     return ;

free(*p);
*p = NULL;
}

PLINK_LIST_T linkList_init(VOID)
{
PLINK_LIST_T head = NULL;

head = linkNode_malloc(0);

return head;
}

LINK_NODE_T *linkList_find(PLINK_LIST_T head, INT32_T id)
{
LINK_NODE_T *p = NULL;

p = head->next;
while (p != NULL)
{
if (p->id == id)
return p;
p = p->next;
}
return p;
}

INT32_T linkList_insert(PLINK_LIST_T head, INT32_T id)
{
LINK_NODE_T *p, *new;

if (NULL == head)
return -1;

if (linkList_find(head, id) != NULL)
{
printf("%d is already in the linklist\n", id);
return 0;
}

if ((new = linkNode_malloc(id)) == NULL)
return -1;

p = head->next;
if (p != NULL)
{
/* 在头结点和第一个结点之间插入新结点 */
new->prev = p->prev;
p->prev->next = new;
new->next = p;
p->prev = new;
}
else
{
/* 只有头结点，直接将新结点接在头结点之后 */
head->next = new;
new->prev = head;
}

return 0;
}

INT32_T linkList_delete(PLINK_LIST_T head, INT32_T id)
{
LINK_NODE_T *p = NULL;

if (head == NULL)
return -1;

p = linkList_find(head, id);
if (p == NULL)
{
printf("%d isn't in link list.\n");
return 0;
}

if (p->next == NULL)
{ /* 要删除的结点是双向链表的最后一个结点，直接移除 */
p->prev->next = NULL;

}
else
{
p->prev->next = p->next;
p->next->prev = p->prev;
}

linkNode_free(&p);

return 0;
}

VOID linkList_print(PLINK_LIST_T head)
{
LINK_NODE_T *p;

if (head == NULL)
return;

p = head->next;
while (p != NULL)
{
printf("%d ", p->id);
p = p->next;
}
printf("\n");
return;
}

INT32_T main(VOID)
{
PLINK_LIST_T link = NULL;

link = linkList_init();
linkList_delete(link, 55);
linkList_insert(link, 55);
linkList_insert(link, 95);
linkList_insert(link, 95);
linkList_insert(link, 115);
linkList_insert(link, 135);
linkList_print(link);

linkList_delete(link, 55);
linkList_delete(link, 135);
linkList_print(link);

return 0;
}