用C语言编写一串代码，判断头结点单链表是否为空表

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

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

int isEmpty(Node *head) {
    if (head->next == NULL) {
        return 1;
    } else {
        return 0;
    }
}

int main() {
    Node *head = (Node*)malloc(sizeof(Node));
    head->next = NULL;

    if (isEmpty(head)) {
        printf("The list is empty.\n");
    } else {
        printf("The list is not empty.\n");
    }

    return 0;
}

相关问题

用C语言编写一串代码，将两个升序的头指针型单链表合并为降序的头指针单链表，并且只能用一个函数

以下是用C语言编写的代码，实现将两个升序的头指针型单链表合并为降序的头指针单链表：

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

typedef struct Node {
    int value;
    struct Node* next;
} Node;

Node* mergeLists(Node* l1, Node* l2) {
    Node* result = NULL;

    if (l1 == NULL) {
        return l2;
    }

    if (l2 == NULL) {
        return l1;
    }

    if (l1->value < l2->value) {
        result = l1;
        result->next = mergeLists(l1->next, l2);
    } else {
        result = l2;
        result->next = mergeLists(l1, l2->next);
    }

    return result;
}

int main() {
    Node* l1 = NULL;
    Node* l2 = NULL;

    // Create first linked list
    Node* node1 = (Node*)malloc(sizeof(Node));
    node1->value = 1;

    Node* node2 = (Node*)malloc(sizeof(Node));
    node2->value = 3;

    Node* node3 = (Node*)malloc(sizeof(Node));
    node3->value = 5;

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

    l1 = node1;

    // Create second linked list
    Node* node4 = (Node*)malloc(sizeof(Node));
    node4->value = 2;

    Node* node5 = (Node*)malloc(sizeof(Node));
    node5->value = 4;

    Node* node6 = (Node*)malloc(sizeof(Node));
    node6->value = 6;

    node4->next = node5;
    node5->next = node6;
    node6->next = NULL;

    l2 = node4;

    // Merge lists
    Node* result = mergeLists(l1, l2);

    // Print merged list in descending order
    while (result != NULL) {
        printf("%d ", result->value);
        result = result->next;
    }

    return 0;
}

在代码中，我们定义了一个 `mergeLists` 函数，该函数接收两个参数 `l1` 和 `l2`，它们分别是两个升序的头指针型单链表的头结点指针。该函数的返回值是头指针型单链表的头结点指针，它代表了将两个升序的单链表合并为一个降序单链表后的结果。

函数内部的实现是经典的递归实现，我们首先对边界情况进行了处理：当两个链表中其中一个为空时，我们直接返回另一个链表的头指针。接下来，我们比较两个链表的头结点值大小，将更小的那个链表头结点作为当前链表的头结点，并将其指向递归调用 `mergeLists` 函数的返回结果，这个返回结果也是一个链表的头指针。最终，我们将这一结果返回。

在主函数中，我们创建了两个升序的单链表，并将它们传递给 `mergeLists` 函数，获取到了合并后的降序单链表的头指针。接下来，我们遍历这个新的单链表，并打印每个结点的值，以检查合并结果是否符合我们的预期。

字符串采用带头结点的单链表存储(非紧凑格式)，设计模式匹配算法 Index(S,T)。要求: (1)声明与存储结构相关的类型; (2)用 C语言描述解决问题的算法.

在处理字符串采用带头结点的单链表存储的情况下，我们可以使用动态规划的思想来设计模式匹配算法，例如KMP（Knuth-Morris-Pratt）算法。首先，我们需要声明与链表相关的类型：

// 定义链表节点结构
typedef struct Node {
    char data;       // 节点字符
    struct Node* next; // 指向下一颗节点
} ListNode;

// 定义字符串列表结构
typedef struct {
    ListNode* head; // 头节点
} LinkedListString;

接下来，我们可以编写 `Index` 函数来实现KMP算法：

#include <string.h>

// 计算KMP失败函数
void computeFailArray(int* fail, const char* pattern, int length) {
    int k = 0;
    for (int i = 1; i < length; i++) {
        while (k > 0 && pattern[i] != pattern[k]) {
            k = fail[k - 1];
        }
        if (pattern[i] == pattern[k]) {
            k++;
        }
        fail[i] = k;
    }
}

// 模式匹配函数
int Index(const LinkedListString* S, const LinkedListString* T) {
    int* fail = (int*)malloc(sizeof(int) * T->length); // 初始化失败函数数组
    computeFailArray(fail, T->head->data, T->length); // 计算T的失败函数

    ListNode* S_cur = S->head;
    ListNode* T_cur = T->head;
    int index = 0; // 当前匹配位置

    while (S_cur != NULL && T_cur != NULL) {
        if (S_cur->data == T_cur->data) {
            index++;
            S_cur = S_cur->next;
            T_cur = T_cur->next;
        } else if (index > 0) {
            // 如果在S中有匹配失败，尝试从之前的失败位置开始查找
            index = fail[index - 1];
        } else {
            // 如果S和T当前字符不匹配，且无法回退，返回-1
            S_cur = S_cur->prev;
            T_cur = T_cur->prev;
        }
    }

    free(fail); // 释放内存
    return index == T->length ? index : -1; // 如果完全匹配，返回索引，否则返回-1
}

在这个算法中，`computeFailArray` 函数用于计算模式串T的失败函数，`Index` 函数则遍历主串S，利用失败函数跳过不必要的比较，提高了搜索效率。当匹配结束时，返回当前索引，如果没有找到匹配，返回-1。