数据结构_双链表_C语言

---

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、双链表

1.1概念

双向链表是一种复杂类型的链表，它的节点包含指向序列中前一个节点和下一个节点的指针。 因此，在双向链表中，节点由三部分组成：节点数据，指向下一个节点的指针(next指针)，指向前一个节点的指针(prev指针)。 双向链表中的示例节点如图所示。

1.2初始化

typedef struct Node {
    int data;
    struct Node* pre;
    struct Node* next;
}Node;

Node* initList() {
    Node* L = (Node*)malloc(sizeof(Node));
    L -> data = 0;
    L -> pre = NULL;
    L -> next = NULL;
    return L;
}

1.3头插法

把要传入的data赋值给新建节点的data域，新建结点node的next指向原本头节点的next，然后node的pre指向头节点，
把原本头节点的后一个结点的pre指向node，这样新建结点和 原头节点的下一个结点 互相指向，最后把头节点的next指向新建结点node

void headInsert(Node* L, int data) {
    Node* node = (Node*)malloc(sizeof(Node));
    node -> data = data;
    node -> next = L -> next;
    node -> pre = L;
    if (L -> next) {
        L -> next -> pre = node;
        L -> next = node;
    }
    else {
        L -> next = node;
    }
}

1.4尾插法

把data赋值给新建结点n的data域
利用循环使node指向最后一个结点，新建节点n的指向该结点的next，也就是NULL，然后node的next指向n，新建结点n的pre指向node，最后在头节点的数据域+1，表示增加一个结点。

void tailInsert(Node* L, int data) {
    Node* node = L;
    Node* n = (Node*)malloc(sizeof(Node));
    n -> data = data;
    while (node -> next) {
        node = node -> next;
    }
    n -> next = node -> next;
    node -> next = n;
    n -> pre = node;
    L -> data ++;
}

1.5结点的删除

int Delete(Node* L, int data) {
    Node* node = L->next;
    while (node) {
        if (node -> data == data) {
            node -> pre -> next = node -> next;
            if (node -> next) {
                node -> next -> pre = node -> pre;
            }
            L -> data --;
            free(node);
            return 1;
        }
        node = node -> next;
    }
    return 0;
}

1.6链表的遍历

void printList(Node* L) {
    Node* node = L -> next;
    while (node) {
        printf("%d -> ", node -> data);
        node = node -> next;
    }
    printf("NULL\n");
}

1.7 main

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



typedef struct Node {
    int data;
    struct Node* pre;
    struct Node* next;
}Node;

Node* initList() {
    Node* L = (Node*)malloc(sizeof(Node));
    L -> data = 0;
    L -> pre = NULL;
    L -> next = NULL;
    return L;
}

void headInsert(Node* L, int data) {
    Node* node = (Node*)malloc(sizeof(Node));
    node -> data = data;
    node -> next = L -> next;
    node -> pre = L;
    if (L -> next) {
        L -> next -> pre = node;
        L -> next = node;
    }
    else {
        L -> next = node;
    }
}

void tailInsert(Node* L, int data) {
    Node* node = L;
    Node* n = (Node*)malloc(sizeof(Node));
    n -> data = data;
    while (node -> next) {
        node = node -> next;
    }
    n -> next = node -> next;
    node -> next = n;
    n -> pre = node;
    L -> data ++;
}

int Delete(Node* L, int data) {
    Node* node = L->next;
    while (node) {
        if (node -> data == data) {
            node -> pre -> next = node -> next;
            if (node -> next) {
                node -> next -> pre = node -> pre;
            }
            L -> data --;
            free(node);
            return 1;
        }
        node = node -> next;
    }
    return 0;
}

void printList(Node* L) {
    Node* node = L -> next;
    while (node) {
        printf("%d -> ", node -> data);
        node = node -> next;
    }
    printf("NULL\n");
}

int main()
{
    Node* L = initList();
    headInsert(L, 1);
    headInsert(L, 2);
    headInsert(L, 3);
    headInsert(L, 4);
    tailInsert(L, 5);
    tailInsert(L, 6);
    printList(L);
    Delete(L, 6);
    printList(L);
    return 0;
}

执行结果：

二、双循环链表

代码示例：

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


typedef struct Node {
    int data;
    struct Node* pre;
    struct Node* next;
}Node;


Node* initList() {
    Node* L = (Node*)malloc(sizeof(Node));
    L -> data = 0;
    L -> pre = L;
    L -> next = L;
    return L;
}


void headInsert(Node* L, int data) {
    Node* node = (Node*)malloc(sizeof(Node));
    node -> data = data;
    node -> next = L -> next;
    node -> pre = L;
    L -> next -> pre = node;
    L -> next = node;
    L -> data ++;
}


void tailInsert(Node* L, int data) {
    Node* node = L;
    while (node->next != L) {
        node = node -> next;
    }
    Node* n = (Node*)malloc(sizeof(Node));
    n -> data = data;
    n -> pre = node;
    n -> next = L;
    L -> pre = n;
    node -> next = n;
    L -> data ++;
}


int Delete(Node* L, int data) {
    Node* node = L -> next;
    while (node != L) {
        if (node -> data == data) {
            node -> pre -> next = node -> next;
            node -> next -> pre = node -> pre;
            free(node);
            L -> data --;
            return 1;
        }
        node = node -> next;
    }
    return 0;
}

void printList(Node* L){
    Node* node = L->next;
    while(node != L){
        printf("%d -> ", node->data);
        node = node->next;
    }
    printf("NULL\n");
}


int main()
{
    Node* L = initList();
    headInsert(L, 1);
    headInsert(L, 2);
    headInsert(L, 3);
    headInsert(L, 4);
    headInsert(L, 5);
    printList(L);
    tailInsert(L, 6);
    tailInsert(L, 7);
    printList(L);
    Delete(L, 7);
    printList(L);
    return 0;
}

执行结果：

---

个人学习笔记，如有错误，敬请指正。