请用C语言实现，且两个链表中的结点都要删除

假设有两个链表A和B，现在需要删除它们中的所有结点。

链表结点的定义：

struct ListNode {
    int val;
    struct ListNode *next;
};

删除链表的函数：

void deleteList(struct ListNode *head) {
    struct ListNode *temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp);
    }
}

由于需要删除两个链表，因此可以在主函数中依次调用上述函数：

int main() {
    struct ListNode *listA, *listB;
    // 初始化链表A和链表B
    deleteList(listA);
    deleteList(listB);
    return 0;
}

相关问题

用c语言实现带头结点的链表

好的，我可以帮你解答关于C语言实现带头结点的链表的问题。你可以使用结构体来定义节点，同时在头文件中声明头结点，并在初始化函数中为头结点分配空间，这样就可以方便地插入、删除和遍历链表了。具体实现可以参考下面的代码：

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

//定义结构体，包含两个成员：数据和下一个节点的指针
typedef struct node {
    int data;
    struct node *next;
} Node;

//头文件中声明头结点
Node *head;

//初始化函数，为头结点分配空间
void init() {
    head = (Node *)malloc(sizeof(Node));
    head->next = NULL;
}

//插入函数
void insert(int x) {
    Node *p = head;
    Node *new_node = (Node *)malloc(sizeof(Node));
    if (new_node == NULL) {
        printf("Error: memory allocation failed!\n");
        exit(1);
    }
    new_node->data = x;
    new_node->next = NULL;

    while (p->next != NULL) {
        p = p->next;
    }
    p->next = new_node;
}

//删除函数
void delete(int x) {
    Node *p = head->next;
    Node *prev = head;
    while (p != NULL) {
        if (p->data == x) {
            prev->next = p->next;
            free(p);
            return;
        }
        prev = p;
        p = p->next;
    }
    printf("Error: element not found!\n");
}

//遍历函数
void traverse() {
    Node *p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

//主函数
int main() {
    init();
    insert(1);
    insert(2);
    insert(3);
    traverse();
    delete(2);
    traverse();
    return 0;
}

希望这能够帮助到你！如果你还有其他问题，可以继续问我哦。现在请听一个不太好笑的笑话：为什么程序员总是固执地认为 Unix 是最好的操作系统？因为他们自己编译了它。

用C语言实现一个删除两个双向链表中相同结点的函数

以下是用C语言实现删除两个双向链表中相同结点的函数的示例代码：

#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));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

void deleteNode(Node* node) {
    if (node == NULL) {
        return;
    }
    if (node->prev != NULL) {
        node->prev->next = node->next;
    }
    if (node->next != NULL) {
        node->next->prev = node->prev;
    }
    free(node);
}

void deleteCommonNodes(Node* list1, Node* list2) {
    Node* p = list1;
    while (p != NULL) {
        Node* q = list2;
        while (q != NULL) {
            if (p->data == q->data) {
                deleteNode(p);
                deleteNode(q);
                break;
            }
            q = q->next;
        }
        p = p->next;
    }
}

int main() {
    Node* list1 = createNode(1);
    list1->next = createNode(2);
    list1->next->prev = list1;
    list1->next->next = createNode(3);
    list1->next->next->prev = list1->next;

    Node* list2 = createNode(2);
    list2->next = createNode(3);
    list2->next->prev = list2;

    deleteCommonNodes(list1, list2);

    Node* p = list1;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");

    Node* q = list2;
    while (q != NULL) {
        printf("%d ", q->data);
        q = q->next;
    }
    printf("\n");

    return 0;
}

在此示例代码中，我们定义了一个 `Node` 结构体表示链表的结点，其中包括数据、前驱结点和后继结点三个成员变量。我们还定义了 `createNode` 函数用于创建链表结点，以及 `deleteNode` 函数用于删除某个结点。

在 `deleteCommonNodes` 函数中，我们对两个链表中的每一个结点进行比较，如果它们的数据相同，则删除它们。在删除结点时，我们调用 `deleteNode` 函数删除结点，并将该结点的前驱结点和后继结点进行连接。

在 `main` 函数中，我们创建了两个双向链表并分别赋值，然后调用 `deleteCommonNodes` 函数删除它们的相同结点。最后，我们遍历两个链表并输出它们的值，以检查删除操作是否成功。

需要注意的是，此示例代码仅适用于数据类型为整数的链表。若要支持其他数据类型，需要相应地修改代码。