删除带头节点单链表l中重复的节点c语言

在C语言中，删除单链表`l`中的重复节点通常是通过遍历链表并比较节点值来实现的。这里提供一种基本的方法：

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

void deleteDuplicates(Node** l) {
    if (*l == NULL) return; // 空链表不需要处理

    Node* current = *l;
    while (current != NULL) {
        Node* nextTemp = current->next;
        
        // 如果当前节点的数据和下一个节点的数据相同，则跳过这个重复的节点
        while (nextTemp != NULL && nextTemp->data == current->data) {
            nextTemp = nextTemp->next;
        }
        
        // 将指向最后一个不同数据节点的指针更新回下一个非重复节点
        current->next = nextTemp;
        
        // 移动到下一个节点
        current = nextTemp;
    }
}

这个函数接受链表头结点的地址作为输入，它会遍历链表，如果遇到重复的节点，则跳过它们，直到找到下一个不同值的节点。最后，链表中的重复节点将不会被包含在结果中。

相关问题

递归法返回带头节点单链表中最小值c语言代码

在C语言中，如果你想要通过递归的方式找到单链表中的最小值，并且链表的头节点已经存在，你可以使用下面的代码：

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

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

// 递归函数，获取链表的最小值
int findMin(Node* head) {
    // 如果链表为空或只有一个元素，直接返回头节点的值
    if (head == NULL || head->next == NULL) {
        return head->data;
    }

    // 否则，递归地比较当前节点和它的下一个节点的最小值
    return (head->data < head->next->data) ? head->data : findMin(head->next);
}

int main() {
    // 创建一个示例链表
    Node* list = (Node*)malloc(sizeof(Node));
    list->data = 5;
    list->next = (Node*)malloc(sizeof(Node));
    list->next->data = 2;
    list->next->next = (Node*)malloc(sizeof(Node));
    list->next->next->data = 9;
    list->next->next->next = NULL; // 设置尾部指针

    // 打印最小值
    int min = findMin(list);
    printf("The minimum value in the linked list is: %d\n", min);

    // 释放内存
    free(list);
    free(list->next);
    free(list->next->next);

    return 0;
}

在这个代码里，`findMin`函数会一直递归直到链表变为空或只有一个元素，然后返回这个元素作为最小值。

将带头节点单链表逆置递归c语言

在C语言中，你可以使用递归来实现带头节点单链表的反转。这里是一个简单的示例：

首先，我们需要定义链表节点结构体和头结点变量：

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

Node* head = NULL; // 假设head已经指向了链表的第一个元素

接下来，定义一个递归函数`reverseListRecursively(Node* curr)`，它会接收当前节点作为参数，并返回反转后的链表头。

Node* reverseListRecursively(Node* curr) {
    if (curr == NULL || curr->next == NULL) { // 如果当前节点为空或者已经是最后一个节点，直接返回
        return curr;
    }

    // 递归：先处理下一个节点
    Node* nextTemp = curr->next;
    curr->next = reverseListRecursively(nextTemp); // 令当前节点的next指向递归的结果

    // 最后将递归回来的链表接到当前节点的尾部
    nextTemp->next = curr;

    return nextTemp; // 返回反转后的新头节点

要实际反转链表，只需调用这个函数并更新头节点：

head = reverseListRecursively(head);