Doubly Linked List&DLL（双向链表）

双向链表

优点

1. 可以从两个方向遍历链表（从前到后，从后到前）；
2. 删除节点方面效率很高（不像单链表和循环链表需要遍历链表）；
3. 可以插入元素在给定节点之前（单链表和循环链表只能插在给定节点后面，除了插在头结点之前）；

缺点

1. 一个双向链表节点要存储两个指针，一个指向下一个节点next，一个指向上一个节点previous，耗费空间资源比较大相较于单链表和循环链表。（这个有XOR链表解决这个问题）

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

struct node
{
    int data;
    struct node * pre;
    struct node * next;
};

void push(struct node ** head_ref, int new_data)
{
    struct node * new_node = (struct node *)malloc(sizeof(struct node));
    new_node->data = new_data;
    new_node->next = (*head_ref);
    new_node->pre = NULL;
    //如果链表不为空的话，将上一个头结点的pre指向新的头结点
    if(NULL != (*head_ref))
    {
        (*head_ref)->pre = new_node;
    }

    (*head_ref) = new_node;
}
void insertAfter(struct node * pre_node, int new_data)
{
    if(NULL == pre_node)
    {
        printf("
ERROR");
        return ;
    }
    struct node * new_node = (struct node *)malloc(sizeof(struct node));

    new_node->data = new_data;

    new_node->next = pre_node->next;
    pre_node->next = new_node;

    new_node->pre = pre_node;
    //如果pre_node不是尾节点的话
    if(NULL != new_node->next)
    {
        new_node->next->pre = new_node;
    }
}
void insertBefore(struct node * next_node, int new_data)
{
    if(NULL == next_node)
    {
        printf("
ERROR");
        return ;
    }
    struct node * new_node = (struct node *)malloc(sizeof(struct node));

    new_node->data = new_data;
    new_node->pre = next_node->pre;
    next_node->pre = new_node;
    new_node->next = next_node;
    //若果next_node不是头结点
    if(NULL != new_node->pre)
    {
        new_node->pre->next = new_node;
    }
}
void append(struct node ** head_ref, int new_data)
{
    struct node * new_node = (struct node *)malloc(sizeof(struct node));
    struct node * last_node = (*head_ref);
    new_node->data = new_data;
    new_node->next = NULL;

    if(NULL == (*head_ref))
    {
        new_node->pre = NULL;
        (*head_ref) = new_node;
        return;
    }
    while(NULL != last_node)
    {
        last_node = last_node->next;
    }
    last_node->next = new_node;
    new_node->pre = last_node;
}
void deleteElement(struct node ** head_ref, struct node * del)
{
    if(NULL == head_ref && NULL == del)
    {
        printf("
ERROR");
        return ;
    }
    //若删除节点为头结点的next节点
    if((*head_ref)->next == del)
    {
        (*head_ref)->next = del->next;
        del->next->pre = (*head_ref);
    }
    //删除节点不是尾节点的时候
    if(NULL != del->next)
    {
        del->next->pre = del->pre;
    }
    //删除节点不是头结点的时候
    if(NULL != del->pre)
    {
        del->pre->next = del->next;
    }

    free(del);
}
void printList(struct node * node)
{
    if(NULL == node)
    {
        printf("
ERROR");
        return ;
    }

    struct node * last = NULL;
    printf("Traversal the list forward direction
");
    while(NULL != node)
    {
        printf("%d  ", node->data);
        last = node;
        node = node->next;
    }
    printf("
Traversal the list reverse direction
");
    while(NULL != last)
    {
        printf("%d  ", last->data);
        last = last->pre;
    }
}
int main(void)
{
    struct node * head = NULL;

    push(&head, 1);
    push(&head, 4);
    push(&head, 5);
    push(&head, 2);

    deleteElement(&head, head->next->next);
    printList(head);

    return 0;
}

感受颇多