设计算法删除带头结点的单链表中数据值大于 min 并且小于 max 的结点。用c语言实现

下面是一个C语言的算法实现，它删除了带头结点的单链表中数据值大于 min 并且小于 max 的节点：

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

// 定义单链表节点的结构体
typedef struct Node {
    int data;
    struct Node* next;
} Node, *LinkedList;

// 创建新节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (!newNode) {
        return NULL;  // 内存分配失败
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 删除链表中值在[min, max]范围内的节点
void removeNodes(LinkedList head, int min, int max) {
    Node* current = head->next;  // 当前节点从第一个实际节点开始
    Node* prev = head;         // 前驱节点始终指向头结点

    while (current != NULL) {
        if (current->data > min && current->data < max) {
            // 需要删除当前节点
            prev->next = current->next; // 将前驱节点的next指向当前节点的next
            free(current);             // 释放当前节点
            current = prev->next;      // 更新当前节点为新的节点
        } else {
            prev = current;   // 如果不删除，前移前驱节点和当前节点
            current = current->next;
        }
    }
}

// 打印链表
void printList(LinkedList head) {
    Node* current = head->next;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

// 主函数
int main() {
    // 创建带头结点的单链表
    LinkedList head = createNode(0);  // 创建头结点，赋值为0，不存储有效数据
    head->next = createNode(1);
    head->next->next = createNode(5);
    head->next->next->next = createNode(10);
    head->next->next->next->next = createNode(15);
    head->next->next->next->next->next = createNode(20);

    printf("原始链表: ");
    printList(head);

    int min = 6, max = 16;
    removeNodes(head, min, max);

    printf("删除指定范围内的节点后的链表: ");
    printList(head);

    // 释放链表内存
    Node* temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp);
    }

    return 0;
}

程序解释：

1. 创建新节点：createNode 函数用于创建并初始化一个新节点。
2. 删除节点：removeNodes 函数遍历链表，删除所有数据值大于 min 并且小于 max 的节点。
3. 打印链表：printList 函数用于打印链表的所有元素。
4. 主函数：创建链表并插入示例数据，然后调用 removeNodes 函数删除特定范围内的节点，并打印结果。

注意事项：

• 在实际应用中，需要确保正确地释放所有分配的内存以避免内存泄漏。
• 这个算法的时间复杂度是 O(n)，其中 n 是链表的长度，因为每个节点最多被访问一次。