c语言在单链表中删除值相同

的节点可以通过遍历单链表，逐个比较节点的值，如果找到值相同的节点，则将该节点从链表中删除。

具体实现可以采用一个指针p指向当前节点，另一个指针q指向p的前一个节点。在遍历过程中，如果发现p节点的值与目标值相同，则将q节点的next指针指向p节点的next指针，然后释放p节点的内存空间。如果p节点不是目标节点，则将q指针指向当前节点p，继续遍历下一个节点。

示例代码如下：

void deleteNode(int value, Node **head) {
    Node *p, *q;
    p = *head;
    q = NULL;

    while (p != NULL) {
        if (p->data == value) {
            if (q == NULL) {
                // 删除头节点
                *head = p->next;
            } else {
                // 删除中间或尾部节点
                q->next = p->next;
            }
            free(p);
            p = q->next;
        } else {
            q = p;
            p = p->next;
        }
    }
}

相关问题

C语言删除单链表中相同的数据

在C语言中，删除单链表中所有相同数据的操作可以通过遍历链表并利用指针链接节点的方式来完成。以下是基本的步骤：

1. 定义结构体`ListNode`表示链表节点，包含一个整型数据`data`和指向下一个节点的指针`next`。

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

2. 创建一个函数`deleteDuplicates`，它接受链表头节点作为参数。

void deleteDuplicates(ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return; // 如果链表为空或只有一个元素，无需删除
    }

    ListNode* current = head;
    while (current != NULL) {
        ListNode* runner = current->next;
        while (runner != NULL) {
            if (current->data == runner->data) { // 如果当前节点值等于运行者节点值
                ListNode* temp = runner; // 临时保存需要删除的节点
                runner = runner->next; // 更新运行者节点到下一个
                free(temp); // 释放内存，并将当前节点的next指向前一个节点
                current->next = runner; // 当前节点的next跳过已删除的节点
            } else {
                runner = runner->next;
            }
        }
        current = current->next;
    }
}

这个函数会遍历整个链表，如果遇到相同的节点，就直接跳过它，通过`free`释放不需要的内存，同时更新当前节点的`next`指针指向下一个非重复节点。

用C语言删除单链表中重复的元素

以下是用C语言删除单链表中重复元素的代码：

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

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

void deleteDuplicates(struct Node* head) {
    struct Node *cur, *pre, *temp;
    cur = head->next;
    while (cur != NULL) {
        pre = cur;
        while (pre->next != NULL) {
            if (pre->next->data == cur->data) {
                temp = pre->next;
                pre->next = pre->next->next;
                free(temp);
            } else {
                pre = pre->next;
            }
        }
        cur = cur->next;
    }
}

void printList(struct Node* head) {
    struct Node* cur = head->next;
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");
}

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

    struct Node* node1 = (struct Node*)malloc(sizeof(struct Node));
    node1->data = 1;
    head->next = node1;

    struct Node* node2 = (struct Node*)malloc(sizeof(struct Node));
    node2->data = 2;
    node1->next = node2;

    struct Node* node3 = (struct Node*)malloc(sizeof(struct Node));
    node3->data = 2;
    node2->next = node3;

    struct Node* node4 = (struct Node*)malloc(sizeof(struct Node));
    node4->data = 3;
    node3->next = node4;

    printf("Original list: ");
    printList(head);

    deleteDuplicates(head);

    printf("List after deleting duplicates: ");
    printList(head);

    return 0;
}

该程序创建了一个单链表，然后调用 `deleteDuplicates` 函数来删除重复的元素。该函数使用两个指针 `cur` 和 `pre`，其中 `cur` 指向当前要查找重复元素的节点，`pre` 则指向 `cur` 的前一个节点。函数内部使用嵌套循环，第一个循环遍历链表中的每个节点，第二个循环则从 `pre` 开始遍历节点，查找与当前节点 `cur` 的元素是否相同。如果找到了相同的元素，则删除该节点，并更新 `pre` 的 `next` 指针，否则继续向后遍历。最终，函数将删除所有重复的元素。

输出结果如下所示：

Original list: 1 2 2 3 
List after deleting duplicates: 1 2 3