C语言双链表基本操作

C语言中的双链表是一种数据结构，每个节点包含两个指针，分别指向前一个节点和后一个节点。双链表的基本操作包括：

1. **创建节点**：创建一个新的节点，通常分配内存并初始化指针，例如`struct Node* newNode = malloc(sizeof(struct Node))`。

2. **插入元素**：
- **头插法**: 如果链表为空，将新节点设置为头结点；否则，将新节点的next指向前一个头结点，并更新头结点的prev指针。
- **尾插法**: 同样，如果链表为空，直接设置；非空链表，则找到最后一个节点，将其next指向新节点，新节点的prev设为旧尾节点。

3. **删除节点**：
- **删除头节点**: 确保有下一个节点，然后更新头节点为下一个节点，同时释放原头节点的内存。
- **删除指定节点**: 需要遍历查找目标节点的前驱节点，将前驱节点的next指针指向目标节点的后继节点，然后释放目标节点内存。

4. **遍历链表**：可以使用两个指针，一个当前节点，一个前一个节点，逐个访问每个节点。

5. **查找和搜索**：根据给定条件（如值、地址等）寻找特定节点。

6. **更新节点值**：定位到某个节点后，修改其值即可。

相关问题

c语言双向链表的创建

双向链表是一种链式存储结构，每个节点有两个指针，分别指向前驱节点和后继节点。下面是C语言实现双向链表的基本步骤：

1. 定义双向链表节点结构体，包含数据域和两个指针域。
2. 定义头节点和尾节点指针，并初始化为空。
3. 实现节点的插入操作，包括在链表头部插入、尾部插入和中间插入。
4. 实现节点的删除操作，包括删除头节点、尾节点和中间节点。
5. 实现遍历链表的操作，包括正向遍历和反向遍历。

下面是一个简单的双向链表创建的示例代码：

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

// 双向链表节点结构体
typedef struct node {
    int data;
    struct node *prev;
    struct node *next;
} Node;

// 头节点和尾节点指针
Node *head = NULL;
Node *tail = NULL;

// 在链表头部插入节点
void insertAtHead(int data) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;    newNode->prev = NULL;
    newNode->next = head;
    if (head != NULL) {
        head->prev = newNode;
    } else {
        tail = newNode;
    }
    head = newNode;
}

// 在链表尾部插入节点
void insertAtTail(int data) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->prev = tail;
    newNode->next = NULL;
    if (tail != NULL) {
        tail->next = newNode;
    } else {
        head = newNode;
    }
    tail = newNode;
}

// 在链表中间插入节点
void insertAtMiddle(int data, int position) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    Node *current = head;
    int i;
    for (i = 1; i < position && current != NULL; i++) {
        current = current->next;
    }
    if (current == NULL) {
        printf("插入位置无效\n");
        return;
    }
    newNode->prev = current->prev;
    newNode->next = current;
    current->prev->next = newNode;
    current->prev = newNode;
}

// 删除头节点
void deleteAtHead() {
    if (head == NULL) {
        printf("链表为空\n");
        return;
    }
    Node *temp = head;
    head = head->next;
    if (head != NULL) {
        head->prev = NULL;
    } else {
        tail = NULL;
    }
    free(temp);
}

// 删除尾节点
void deleteAtTail() {
    if (tail == NULL) {
        printf("链表为空\n");
        return;
    }
    Node *temp = tail;
    tail = tail->prev;
    if (tail != NULL) {
        tail->next = NULL;
    } else {
        head = NULL;
    }
    free(temp);
}

// 删除中间节点
void deleteAtMiddle(int position) {
    Node *current = head;
    int i;
    for (i = 1; i < position && current != NULL; i++) {
        current = current->next;
    }
    if (current == NULL) {
        printf("删除位置无效\n");
        return;
    }
    current->prev->next = current->next;
    current->next->prev = current->prev;
    free(current);
}

// 正向遍历链表
void traverseForward() {
    Node *current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

// 反向遍历链表
void traverseBackward() {
    Node *current = tail;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->prev;
    }
    printf("\n");
}

int main() {
    insertAtHead(1);
    insertAtHead(2);
    insertAtTail(3);
    insertAtMiddle(4, 2);
    traverseForward();
    deleteAtHead();
    deleteAtTail();
    deleteAtMiddle(2);
    traverseBackward();
    return 0;
}

c语言双向循环链表基本操作,请用代码展示

以下是 C 语言双向循环链表的基本操作代码：

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

struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
};

struct Node* head = NULL;

// 在链表末尾插入节点
void insert(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;

    if (head == NULL) {
        head = newNode;
        head->prev = head;
        head->next = head;
    } else {
        struct Node* lastNode = head->prev;
        lastNode->next = newNode;
        newNode->prev = lastNode;
        newNode->next = head;
        head->prev = newNode;
    }
}

// 在链表中删除节点
void delete(int data) {
    if (head == NULL) {
        printf("链表为空，无法删除节点！\n");
        return;
    }

    struct Node* currentNode = head;
    while (currentNode->data != data) {
        currentNode = currentNode->next;
        if (currentNode == head) {
            printf("链表中没有该节点！\n");
            return;
        }
    }

    if (currentNode == head) {
        head = head->next;
    }

    struct Node* prevNode = currentNode->prev;
    struct Node* nextNode = currentNode->next;
    prevNode->next = nextNode;
    nextNode->prev = prevNode;

    free(currentNode);
}

// 在链表中查找节点
void search(int data) {
    if (head == NULL) {
        printf("链表为空，无法查找节点！\n");
        return;
    }

    struct Node* currentNode = head;
    while (currentNode->data != data) {
        currentNode = currentNode->next;
        if (currentNode == head) {
            printf("链表中没有该节点！\n");
            return;
        }
    }

    printf("链表中存在节点 %d\n", data);
}

// 打印链表中的所有节点
void print() {
    if (head == NULL) {
        printf("链表为空，无法打印节点！\n");
        return;
    }

    struct Node* currentNode = head;
    do {
        printf("%d ", currentNode->data);
        currentNode = currentNode->next;
    } while (currentNode != head);
    printf("\n");
}

int main() {
    insert(1);
    insert(2);
    insert(3);
    insert(4);
    insert(5);

    print(); // 输出：1 2 3 4 5

    delete(3);

    print(); // 输出：1 2 4 5

    search(4); // 输出：链表中存在节点 4

    return 0;
}

以上代码实现了双向循环链表的基本操作，包括在链表末尾插入节点、在链表中删除节点、在链表中查找节点以及打印链表中的所有节点。