双向链表需要定义一个结构体，结构体有3个属性

typedef struct __Node{
    int data;    数据
    struct __Node *pre;    指向前一个结点指针
    struct __Node *next;    指向下一个结点指针
}Node;

其中 pre和next指针是嵌套定义。

 

一般链表定义一个头指针

Node *head；

指向链表第一个结点，如果链表为空的话，那么head == NULL。

 

双向链表一般分为init，insert, delete, search, destroy等几种操作

1、init

初始化：将头指针head置为NULL即可

 

2、insert

插入：这里我只实现了在表头位置插入新元素。在表头位置插入元素的话，需要注意区别处理空表和非空表的情况。

1）空表的话，因为有init过程，所以head为NULL，新元素的next指针指向head（NULL），同时设置新元素的pre指针为NULL即可。

2）非空表的话，需要设置以前的头结点元素的pre指针，因为头结点的pre指针都是NULL。其他和空表一样操作。

 

如果要实现在链表的指定位置插入的话，需要先遍历链表找到那个位置，然后再插入。

 

3、delete

删除：这里我实现了删除第一个元素和删除指定的元素。其中删除指定的元素需要查找。

 

4、search

查找：遍历链表进行查找即可

 

5、destroy

销毁：将每个结点开辟的内存分别释放，最后将头结点指针head置为NULL即可。

 

在以上操作过程中，要注意当链表非空时，一定要保证尾结点的next域为NULL，头结点的pre域为NULL，否则容易导致错误！

 

C语言实现代码如下：

 

#include <stdio.h>  
#include <stdlib.h>  
//定义结点  
typedef struct __Node{  
    int data;  
    struct __Node *pre;  
    struct __Node *next;  
}Node;  
//定义带头结点的双向链表  
typedef struct __doublyLinkedList{  
    Node * head;  
}dLinkedList;  
//初始化：头结点置空  
void init(dLinkedList *L){  
    if(L == NULL){  
        printf("链表异常/n");  
        return;  
    }  
    L->head = NULL;  
}  
//  
void insert(dLinkedList *L, int data){  
    Node *p = NULL;  
    if(L == NULL){  
        printf("双向链表不存在/n");  
        return;  
    }  
      
    p = (Node*)malloc(sizeof(Node));  
    if(p == NULL){  
        printf("内存分配失败!/n");  
        return;  
    }  
    p->data = data;  
    p->next = L->head;  
    if(L->head != NULL){  
        L->head->pre = p;  
    }  
    p->pre = NULL;  
    L->head = p;  
}  
Node *search(dLinkedList L, int data){  
    Node *p = NULL;  
    if(L.head == NULL){  
        printf("链表为空/n");  
        return NULL;  
    }  
    p = L.head;  
      
    while(p != NULL && p->data != data){  
        p = p->next;  
    }  
    if(p != NULL){  
        printf("查找值为 %d的元素成功/n", data);  
        return p;  
    }  
    else{  
        printf("查找值为 %d的元素失败/n", data);  
        return NULL;  
    }  
}  
void deleteFirstData(dLinkedList *L){  
    Node *p = NULL;  
    if(L == NULL){  
        printf("双向链表异常!/n");  
        return;  
    }  
    if(L->head == NULL){  
        printf("双向链表为空!/n");  
        return;  
    }  
      
    p = L->head;  
    //only one element  
    if(p->next == NULL){  
        L->head = NULL;  
        free(p);  
        p = NULL;  
        printf("成功删除第一个元素!/n");  
        return;  
    }  
    else{  
        L->head = p->next;  
        L->head->pre = NULL;  
        free(p);  
        p = NULL;  
        printf("成功删除第一个元素!/n");  
        return;  
    }  
      
}  
void deleteData(dLinkedList *L, int data){  
    Node *p = NULL;  
    Node *pre = NULL;  
    printf("删除查找中.../n");  
    if((p = search(*L, data)) == NULL){  
        printf("删除值为 %d的元素失败/n", data);  
        return;  
    }  
    else{  
        //first element  
        if(p == L->head){  
            deleteFirstData(L, data);  
            return;  
        }  
        //last element  
        else if(p->next == NULL){  
            pre = p->pre;  
            pre->next = NULL;  
            free(p);  
            p = NULL;  
            printf("删除最后一个元素成功/n/n");  
            return;  
        }  
        else{  
            pre = p->pre;  
            pre->next = p->next;  
            p->next->pre = pre;  
            free(p);  
            p = NULL;  
            printf("删除值为 %d的元素成功/n/n", data);  
            return;  
        }  
    }  
}  
void traversal(dLinkedList L){  
    Node *p = NULL;  
    if(L.head == NULL){  
        printf("双向链表为空!/n");  
        return;  
    }  
    p = L.head;  
    while(p != NULL){  
        printf("%d ", p->data);  
        p = p->next;  
    }  
    printf("/n遍历成功/n/n");  
}  
void destroy(dLinkedList *L){  
    Node *p = NULL;  
    Node *temp = NULL;  
    if(L == NULL){  
        printf("链表异常/n");  
        return;  
    }  
    printf("开始销毁链表.../n");  
    p = L->head;  
    while(p != NULL){  
        temp = p;  
        p = p->next;  
        free(temp);  
        temp = NULL;  
    }  
    L->head = NULL;  
    printf("销毁成功!/n");  
}  
int main(int argc, char **args){  
    dLinkedList L;  
    int i;  
    memset(&L, 0, sizeof(dLinkedList));  
    init(&L);  
    traversal(L);  
    for(i=0;i<20;++i){  
        insert(&L, i);  
    }  
    traversal(L);  
    deleteFirstData(&L);  
    deleteFirstData(&L);  
    traversal(L);  
      
    deleteFirstData(&L);  
    deleteData(&L, 10);  
    deleteData(&L, 16);  
    deleteData(&L, 0);  
    traversal(L);  
      
    insert(&L, 100);  
    insert(&L, 99);  
    insert(&L, 98);  
    insert(&L, 97);  
    traversal(L);  
    deleteData(&L, 99);  
    deleteData(&L, 97);  
    deleteData(&L, 96);  
    traversal(L);  
    destroy(&L);  
    return 0;  
}

 

 

输出如下

 

双向链表为空!
19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
遍历成功

成功删除第一个元素!
成功删除第一个元素!
17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
遍历成功

成功删除第一个元素!
删除查找中...
查找值为 10的元素成功
删除值为 10的元素成功

删除查找中...
查找值为 16的元素成功
成功删除第一个元素!
删除查找中...
查找值为 0的元素成功
删除最后一个元素成功

15 14 13 12 11 9 8 7 6 5 4 3 2 1
遍历成功

97 98 99 100 15 14 13 12 11 9 8 7 6 5 4 3 2 1
遍历成功

删除查找中...
查找值为 99的元素成功
删除值为 99的元素成功

删除查找中...
查找值为 97的元素成功
成功删除第一个元素!
删除查找中...
查找值为 96的元素失败
删除值为 96的元素失败
98 100 15 14 13 12 11 9 8 7 6 5 4 3 2 1
遍历成功

开始销毁链表...
销毁成功!
Press any key to continue