c语言如何定义一组双向链表

C语言定义一组双向链表的方法

定义结构体、创建节点、连接节点

在C语言中，双向链表是一种常见的数据结构，它允许在节点之间进行双向遍历。要定义一组双向链表，首先需要定义节点结构体，然后通过创建节点和连接节点来实现链表。下面我们详细介绍如何在C语言中定义和操作双向链表。

一、定义节点结构体

在C语言中，定义双向链表的第一步是定义节点结构体。双向链表的每个节点包含三个部分：一个数据域和两个指针域。一个指针指向前一个节点，另一个指针指向下一个节点。

typedef struct Node {
    int data; // 数据域
    struct Node* prev; // 指向前一个节点的指针
    struct Node* next; // 指向下一个节点的指针
} Node;

二、创建节点

创建节点是双向链表的基本操作之一。我们需要编写一个函数来创建节点，并初始化节点的数据和指针。

Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node)); // 动态分配内存
    if (!newNode) {
        printf("Memory allocation failedn");
        exit(1);
    }
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

三、插入节点

插入节点是双向链表中一个非常重要的操作。我们可以在链表的头部、尾部或任意位置插入节点。

1、在头部插入节点

在链表头部插入节点时，需要调整新节点和头节点的指针。

void insertAtHead(Node head, int data) {
    Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
    } else {
        newNode->next = *head;
        (*head)->prev = newNode;
        *head = newNode;
    }
}

2、在尾部插入节点

在链表尾部插入节点时，需要遍历链表找到最后一个节点，然后调整指针。

void insertAtTail(Node head, int data) {
    Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
    } else {
        Node* temp = *head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
        newNode->prev = temp;
    }
}

3、在任意位置插入节点

在任意位置插入节点时，需要找到要插入位置的前一个节点，然后调整指针。

void insertAtPosition(Node head, int data, int position) {
    if (position == 0) {
        insertAtHead(head, data);
        return;
    }
    Node* newNode = createNode(data);
    Node* temp = *head;
    for (int i = 0; i < position - 1 && temp != NULL; i++) {
        temp = temp->next;
    }
    if (temp == NULL) {
        printf("Position out of boundsn");
        return;
    }
    newNode->next = temp->next;
    newNode->prev = temp;
    if (temp->next != NULL) {
        temp->next->prev = newNode;
    }
    temp->next = newNode;
}

四、删除节点

删除节点也是双向链表中的一个关键操作。我们可以删除头节点、尾节点或任意位置的节点。

1、删除头节点

删除头节点时，需要调整头节点的指针。

void deleteHead(Node head) {
    if (*head == NULL) {
        return;
    }
    Node* temp = *head;
    *head = (*head)->next;
    if (*head != NULL) {
        (*head)->prev = NULL;
    }
    free(temp);
}

2、删除尾节点

删除尾节点时，需要遍历链表找到最后一个节点，然后调整指针。

void deleteTail(Node head) {
    if (*head == NULL) {
        return;
    }
    Node* temp = *head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    if (temp->prev != NULL) {
        temp->prev->next = NULL;
    } else {
        *head = NULL;
    }
    free(temp);
}

3、删除任意位置节点

删除任意位置节点时，需要找到要删除节点的位置，然后调整指针。

void deleteAtPosition(Node head, int position) {
    if (*head == NULL) {
        return;
    }
    Node* temp = *head;
    if (position == 0) {
        *head = temp->next;
        if (*head != NULL) {
            (*head)->prev = NULL;
        }
        free(temp);
        return;
    }
    for (int i = 0; temp != NULL && i < position; i++) {
        temp = temp->next;
    }
    if (temp == NULL) {
        printf("Position out of boundsn");
        return;
    }
    if (temp->next != NULL) {
        temp->next->prev = temp->prev;
    }
    if (temp->prev != NULL) {
        temp->prev->next = temp->next;
    }
    free(temp);
}

五、遍历链表

遍历链表是为了访问链表中的每一个节点。我们可以从头到尾或者从尾到头遍历链表。

1、从头到尾遍历链表

void traverseForward(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("n");
}

2、从尾到头遍历链表

void traverseBackward(Node* head) {
    if (head == NULL) {
        return;
    }
    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->prev;
    }
    printf("n");
}

六、释放链表内存

在程序结束时，释放链表占用的内存是非常重要的，以防止内存泄漏。

void freeList(Node* head) {
    Node* temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp);
    }
}

七、完整示例

下面是一个完整的示例代码，演示了双向链表的定义、插入、删除和遍历操作。

#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
} Node;
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (!newNode) {
        printf("Memory allocation failedn");
        exit(1);
    }
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}
void insertAtHead(Node head, int data) {
    Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
    } else {
        newNode->next = *head;
        (*head)->prev = newNode;
        *head = newNode;
    }
}
void insertAtTail(Node head, int data) {
    Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
    } else {
        Node* temp = *head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
        newNode->prev = temp;
    }
}
void insertAtPosition(Node head, int data, int position) {
    if (position == 0) {
        insertAtHead(head, data);
        return;
    }
    Node* newNode = createNode(data);
    Node* temp = *head;
    for (int i = 0; i < position - 1 && temp != NULL; i++) {
        temp = temp->next;
    }
    if (temp == NULL) {
        printf("Position out of boundsn");
        return;
    }
    newNode->next = temp->next;
    newNode->prev = temp;
    if (temp->next != NULL) {
        temp->next->prev = newNode;
    }
    temp->next = newNode;
}
void deleteHead(Node head) {
    if (*head == NULL) {
        return;
    }
    Node* temp = *head;
    *head = (*head)->next;
    if (*head != NULL) {
        (*head)->prev = NULL;
    }
    free(temp);
}
void deleteTail(Node head) {
    if (*head == NULL) {
        return;
    }
    Node* temp = *head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    if (temp->prev != NULL) {
        temp->prev->next = NULL;
    } else {
        *head = NULL;
    }
    free(temp);
}
void deleteAtPosition(Node head, int position) {
    if (*head == NULL) {
        return;
    }
    Node* temp = *head;
    if (position == 0) {
        *head = temp->next;
        if (*head != NULL) {
            (*head)->prev = NULL;
        }
        free(temp);
        return;
    }
    for (int i = 0; temp != NULL && i < position; i++) {
        temp = temp->next;
    }
    if (temp == NULL) {
        printf("Position out of boundsn");
        return;
    }
    if (temp->next != NULL) {
        temp->next->prev = temp->prev;
    }
    if (temp->prev != NULL) {
        temp->prev->next = temp->next;
    }
    free(temp);
}
void traverseForward(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("n");
}
void traverseBackward(Node* head) {
    if (head == NULL) {
        return;
    }
    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->prev;
    }
    printf("n");
}
void freeList(Node* head) {
    Node* temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp);
    }
}
int main() {
    Node* head = NULL;
    insertAtHead(&head, 1);
    insertAtTail(&head, 2);
    insertAtTail(&head, 3);
    insertAtPosition(&head, 4, 1);
    printf("Forward traversal: ");
    traverseForward(head);
    printf("Backward traversal: ");
    traverseBackward(head);
    deleteHead(&head);
    deleteTail(&head);
    deleteAtPosition(&head, 1);
    printf("After deletions, forward traversal: ");
    traverseForward(head);
    freeList(head);
    return 0;
}

八、结论

通过上述步骤，我们详细介绍了如何在C语言中定义一组双向链表，包括定义节点结构体、创建节点、插入节点、删除节点、遍历链表和释放链表内存。双向链表在实际应用中非常有用，理解和掌握双向链表的操作对于C语言编程是非常重要的。希望这篇文章能帮助你更好地理解和使用双向链表。