c语言删除链表中的重复元素

在C语言中，可以通过遍历链表的方式删除链表中的重复元素。具体步骤如下：

1. 定义两个指针p和q，分别指向链表的头结点和下一个节点。
2. 在p不为空时，循环遍历链表，将q指向p的下一个节点。
3. 在q不为空时，比较p和q所指向的节点的值是否相同，若相同，则删除q所指向的节点，并将q指向下一个节点。
4. 若不同，则将p和q同时向后移动一位。
5. 重复执行步骤2-4，直到遍历完整个链表。

具体代码如下：

struct ListNode* deleteDuplicates(struct ListNode* head) {
    struct ListNode *p = head, *q;
    while (p != NULL) {
        q = p->next;
        while (q != NULL) {
            if (p->val == q->val) {
                p->next = q->next;
                free(q);
                q = p->next;
            } else {
                q = q->next;
            }
        }
        p = p->next;
    }
    return head;
}

相关问题

C语言有序链表删除重复元素

在C语言中，如果要删除有序链表中的重复元素，可以采用遍历链表的方式。以下是基本步骤：

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

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

2. 创建一个函数，用于删除重复的元素。这里会创建两个指针，一个当前指针`current`和一个前驱指针`prev`。当遇到相同的元素时，跳过它并继续检查下一个节点。

void removeDuplicates(Node** head) {
    if (*head == NULL || (*head)->next == NULL) {
        return;
    }
    
    Node* current = *head;
    Node* prev = NULL;
    while (current != NULL && current->next != NULL) {
        if (current->data == current->next->data) {
            Node* temp = current->next;
            current->next = current->next->next;
            free(temp); // 释放重复元素的内存
            prev = current; // 非重复元素向前移动
            current = current->next;
        } else {
            prev = current;
            current = current->next;
        }
    }
}

3. 在函数结束时，记得处理链表尾部的情况，如果最后一个节点的数据和前一个节点相同，也需要移除并释放内存。

if (prev != NULL && current != NULL && prev->data == current->data) {
    free(current);
}

4. 调用这个函数时，传入链表头指针即可开始操作：

Node* list = createLinkedList(); // 初始化链表...
removeDuplicates(&list);

删除链表中重复元素 c语言

在C语言中删除链表中重复元素，可以采用双重循环的方式，对链表进行遍历，每当遇到重复的元素，就将其删除即可。具体实现步骤如下：

1. 定义一个指针p1，指向链表的第一个节点。
2. 对链表进行遍历，遍历过程中使用指针p2指向当前节点的下一个节点。
3. 在p2指向的节点后面进行另一次循环，如果发现p2指向的节点与当前节点p1指向的节点相同，则将p2所指向的节点删除。
4. 将p2指向下一个节点，继续进行循环操作，直到p2指向链表末尾。
5. 将p1指向下一个节点，重复以上操作，直到遍历到链表末尾。

以下是一段示例代码：

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

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

Node* deleteDuplicates(Node* head) {
    if (head == NULL) {
        return NULL;
    }
    Node *p1 = head;
    while (p1 != NULL) {
        Node *p2 = p1;
        while (p2->next != NULL) {
            if (p1->data == p2->next->data) {
                Node *tmp = p2->next;
                p2->next = tmp->next;
                free(tmp);
            } else {
                p2 = p2->next;
            }
        }
        p1 = p1->next;
    }
    return head;
}

int main() {
    // 创建链表
    Node *head = (Node*)malloc(sizeof(Node));
    head->data = 1;
    head->next = NULL;
    Node *p = head;
    for (int i = 2; i <= 5; i++) {
        Node *newNode = (Node*)malloc(sizeof(Node));
        newNode->data = i % 3 + 1;
        newNode->next = NULL;
        p->next = newNode;
        p = newNode;
    }
    // 删除重复元素
    head = deleteDuplicates(head);
    // 输出链表
    p = head;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
    // 释放内存
    p = head;
    while (p != NULL) {
        Node *tmp = p;
        p = p->next;
        free(tmp);
    }
    return 0;
}