用c语言写出下面问题：定义一个单链表并删除单链表L中p所指向结点的前驱结点

链表节点定义：

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

删除p的前驱节点：

void deletePredecessor(ListNode *L, ListNode *p) {
    if (L == NULL || p == NULL || L->next == NULL) {
        return;
    }

    ListNode *pre = L;
    ListNode *cur = L->next;

    while (cur != NULL) {
        if (cur == p) {
            pre->next = cur->next;
            free(cur);
            return;
        }
        pre = cur;
        cur = cur->next;
    }
}

相关问题

对给定的单链表 L ，设计一个算法，删除 L 中值为 x 的结点的直接前驱结点，用C语言写

在C语言中，我们可以使用迭代的方式来解决这个问题。假设链表节点结构如下：

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

首先，我们需要找到目标元素x以及它的前一个元素。如果链表头节点就是我们要找的元素，或者找不到该元素，则无需删除。接下来，可以编写如下的函数来完成删除操作：

void deleteNode(ListNode** head, int x) {
    // 检查是否为空链表
    if (*head == NULL) {
        return;
    }

    // 遍历链表
    ListNode* current = *head;
    ListNode* prev = NULL;

    while (current != NULL && current->val != x) {
        // 找到元素x的前一个节点
        prev = current;
        current = current->next;
    }

    // 如果找到了目标元素，删除其前一个节点
    if (current != NULL) {
        if (prev == NULL) {  // 如果头节点就是要删除的元素
            *head = current->next;
        } else {
            prev->next = current->next;
        }
        free(current);  // 释放已删除节点的内存
    }
}

在这个函数里，我们遍历链表，当找到值为x的节点时，记录下它的前一个节点prev，并将prev的next指针指向当前节点的下一个节点，从而实现了删除操作。

设计一个算法，通过一趟遍历查找单链表L中 值最小的结点，并删除该结点。用c语言

设计一个C语言算法来找到并删除单链表L中的最小元素可以分为三个步骤：

1. 初始化：创建两个指针`current`和`minNode`，分别指向链表的头节点和假设为最大值的节点。如果链表为空，直接返回。

struct ListNode* findMin(struct ListNode* head) {
    if (head == NULL) {
        return NULL;
    }
    struct ListNode* current = head;
    struct ListNode* minNode = head;
}

2. 遍历链表：在循环中，每次比较当前节点的值和已知最小值，如果当前节点的值更小，则更新`minNode`。

while (current != NULL) {
    if (current->val < minNode->val) {
        minNode = current;
    }
    current = current->next;
}

3. 删除最小节点：找到最小节点后，需要处理两个情况：
- 如果链表只有一个元素，直接删除并返回NULL；
- 否则，从`minNode`的下一个节点开始连接原来的前驱节点，即`minNode->prev->next = minNode->next`。

if (minNode == head) { // 单个元素的情况
    head = head->next;
} else {
    minNode->prev->next = minNode->next; // 更新前驱节点的next指针
}

return head; // 返回新的链表头

完整函数示例：

struct ListNode* deleteMin(struct ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }

    struct ListNode* current = head;
    struct ListNode* minNode = head;

    while (current != NULL && current->next != NULL) {
        if (current->val < minNode->val) {
            minNode = current;
        }
        current = current->next;
    }

    if (current == NULL) { // 最小值就是最后一个节点
        head = head->next;
    } else {
        minNode->prev->next = minNode->next;
    }

    return head;
}