C语言检查链表是否为空

在C语言中，检查链表是否为空通常通过检查链表的头指针是否为NULL来进行。如果链表为空，那么它的头指针会指向空地址。你可以编写如下的函数来完成这个操作：

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

// 定义链表节点结构
typedef struct Node {
    int data;      // 节点数据
    struct Node* next; // 指向下一个节点的指针
} Node;

// 判断链表是否为空
int isListEmpty(Node* head) {
    if (head == NULL) {   // 如果头指针为NULL，则链表为空
        return 1;
    } else {
        return 0;   // 非空链表返回0表示非空
    }
}

int main() {
    Node* list = NULL; // 创建一个空链表
    if (isListEmpty(list)) {
        printf("链表为空.\n");
    } else {
        printf("链表非空.\n");
    }
    return 0;
}

相关问题

c语言 循环链表反转

循环链表是一种特殊的链表，它的最后一个节点指向首节点，形成一个循环。要对循环链表进行反转，我们需要修改指针的指向关系。

首先，我们需要定义一个指向当前节点的指针，初始时指向循环链表的首节点。然后，我们根据当前节点的指针将链表逐个反转。

具体的反转步骤如下：

1. 首先，检查循环链表是否为空，若为空，则无需反转，直接返回。
2. 将当前节点的指针指向下一个节点。
3. 将下一个节点的指针指向前一个节点。
4. 将前一个节点的指针指向当前节点。
5. 将当前节点的指针指向下一个节点。
6. 重复步骤2-5，直至当前节点指向了起始节点，表示反转完成。

下面是使用C语言实现循环链表反转的代码示例：

#include <stdio.h>

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

// 循环链表反转函数
void reverseLinkedList(struct Node** head) {
    if (*head == NULL) {
        printf("链表为空，无需反转\n");
        return;
    }

    struct Node* current = *head;
    struct Node* nextNode = NULL;
    struct Node* prevNode = NULL;

    do {
        nextNode = current->next;
        current->next = prevNode;
        prevNode = current;
        current = nextNode;
    } while (current != *head);

    (*head)->next = prevNode;
    *head = prevNode;
}

int main() {
    // 创建循环链表
    struct Node* node1 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node2 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node3 = (struct Node*)malloc(sizeof(struct Node));

    node1->data = 1;
    node2->data = 2;
    node3->data = 3;

    node1->next = node2;
    node2->next = node3;
    node3->next = node1;

    // 反转循环链表
    reverseLinkedList(&node1);

    // 输出反转后的循环链表
    struct Node* current = node1;
    do {
        printf("%d ", current->data);
        current = current->next;
    } while (current != node1);

    // 释放内存
    free(node1);
    free(node2);
    free(node3);

    return 0;
}

上述代码中，我们在主函数中创建一个带有三个节点的循环链表，并调用reverseLinkedList函数对其进行反转。最后，我们通过遍历循环链表输出反转后的结果。

c语言双向链表插入和删除

双向链表是一种常见的数据结构，它的每个节点都包含指向前一个节点和后一个节点的指针，这意味着可以在双向链表中向前或向后遍历。下面是C语言中如何实现双向链表的插入和删除操作的示例代码。

首先定义一个双向链表节点的结构体：

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

然后定义一个指向链表头节点和尾节点的指针变量：

Node* head = NULL;
Node* tail = NULL;

接下来是双向链表插入节点的示例代码：

void insertNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node)); // 分配一个新节点
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    
    if (head == NULL) { // 如果链表为空，将新节点作为头节点
        head = newNode;
        tail = newNode;
    }
    else { // 否则将新节点插入到链表尾部
        tail->next = newNode;
        newNode->prev = tail;
        tail = newNode;
    }
}

在上面的代码中，我们首先分配一个新的节点并将其初始化为指定的数据。然后，如果链表为空，则将新节点作为头节点，否则将新节点插入到链表的尾部。

接下来是双向链表删除节点的示例代码：

void deleteNode(Node* node) {
    if (node == head) { // 如果删除的是头节点
        head = node->next;
        if (head != NULL) {
            head->prev = NULL;
        }
    }
    else if (node == tail) { // 如果删除的是尾节点
        tail = node->prev;
        if (tail != NULL) {
            tail->next = NULL;
        }
    }
    else { // 如果删除的是中间节点
        node->prev->next = node->next;
        node->next->prev = node->prev;
    }
    free(node); // 释放节点内存
}

在上面的代码中，我们首先检查要删除的节点是否是头节点或尾节点。如果是头节点，则将头指针指向下一个节点，如果下一个节点不为空，则将其前指针设置为NULL。如果是尾节点，则将尾指针指向前一个节点，如果前一个节点不为空，则将其后指针设置为NULL。如果删除的是中间节点，则将前一个节点的后指针指向下一个节点，将后一个节点的前指针指向前一个节点。最后，我们释放要删除的节点的内存。