自己用C写的list双向链表

自己用C写的list双向链表头文件

#ifndef _LIST_H_
#define _LIST_H_

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

typedef int DataType;
struct node{
    DataType data;
    struct node * next;
    struct node * prev; 
};

typedef struct node Node;

struct list{
    Node * root;
    Node * tail;
    size_t size;
};

typedef struct list List;

void init(List * l);
void destroy(List * l);
size_t size(List * l);
bool isEmpty(List * l);
void addNodeAfter(Node * pn, Node * new_node);
void addFirst(List * l, DataType item);
void addLast(List * l, DataType item);
DataType getFirst(List * l);
DataType getLast(List * l);
void removeNodeAfter(Node * pn);
DataType removeFirst(List * l);
DataType removeLast(List * l);
void showAll(List * l);

//用calloc创建2个带有默认初始值的Node,分别赋给root，和tail,并链接好root和tail.
void init(List * l)
{
    Node * pnode = (Node *)calloc(2, sizeof(Node)); 
    l->root = pnode;
    l->tail = ++pnode;
    l->root->next = l->tail;
    l->tail->prev = l->root; 
    l->size = 0;
}

//释放占用内存
void destroy(List * l)
{
    Node * dnode = NULL;
    while(l->root != NULL)
    {
        dnode = l->root;
        l->root = l->root->next;
        free(dnode);
    }
    l->root = l->tail = NULL;
    l->size = 0;
}

//返回当前元素个数
size_t size(List * l)
{
    return l->size;
}

bool isEmpty(List * l)
{
    return l->size == 0;
}

//将新增节点new_node链接在节点pn后面
void addNodeAfter(Node * pn, Node * new_node)
{
    new_node->next = pn->next;
    pn->next->prev = new_node;
    new_node->prev = pn;
    pn->next = new_node;
}

//向链表头部添加新元素item
void addFirst(List * l, DataType item)
{
    Node *pnode = (Node *)malloc(sizeof(Node));
    pnode->data = item;
    addNodeAfter(l->root, pnode);
    ++(l->size);
}

//向链表尾部添加新元素item
void addLast(List * l, DataType item)
{
    Node *pnode = (Node *)malloc(sizeof(Node));
    pnode->data = item;
    addNodeAfter(l->tail->prev, pnode);
    ++(l->size);
}

//返回链首元素的值
DataType getFirst(List * l)
{
    if(isEmpty(l))
        return -2147483648;
    return l->root->next->data;
}

//返回链尾元素的值
DataType getLast(List * l)
{
    if(isEmpty(l))
        return -2147483648;
    return l->tail->prev->data;
}

//删除pn后面的节点,并释放被删节点占用的内存
void removeNodeAfter(Node * pn)
{
    pn->next = pn->next->next;
    free(pn->next->prev);
    pn->next->prev = pn;

}

//移除链首元素
DataType removeFirst(List * l)
{
    if(isEmpty(l))
        return -2147483648;
    DataType ret = l->root->next->data;
    removeNodeAfter(l->root);
    --(l->size);
    return ret;
}

//移除链尾元素
DataType removeLast(List * l)
{
    if(isEmpty(l))
        return -2147483648;
    DataType ret = l->tail->prev->data;
    removeNodeAfter(l->tail->prev->prev);
    --(l->size);
    return ret;
}

//遍历链表
void showAll(List * l)
{
    if(isEmpty(l))
    {
        printf("empty data!
");
        return;
    }
    Node * current = l->root->next;
    while(current != l->tail)
    {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("
");
}

#endif