删除给定链表中的重复元素（链表中元素从小到大有序排列），使链表中的所有元素都只出现一次，C语言实现

假设链表节点的结构体如下：

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

则可以按照以下步骤实现链表中重复元素的删除：

1. 如果链表为空或只有一个节点，直接返回链表。
2. 定义一个指针p，初始指向链表的第一个节点。
3. 遍历链表，如果当前节点的值和下一个节点的值相等，则删除下一个节点（即将当前节点的next指针指向下一个节点的next指针），继续判断下一个节点。如果不相等，则将p指针指向下一个节点，继续遍历。
4. 返回链表的头节点。

具体代码实现如下：

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

相关问题

java 删除给定链表中的重复元素（链表中元素从小到大有序排列），使链表中的所有元素都只出现一次 一行内输入一串整数，以空格间隔，以# 结束 一串去重后整数，以空格间隔，以# 结束。

您可以使用Java中的链表来实现删除给定链表中的重复元素。以下是一个示例代码：

import java.util.*;

class ListNode {
    int val;
    ListNode next;
    
    ListNode(int val) {
        this.val = val;
        this.next = null;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        String[] numbers = input.split(" ");
        
        ListNode head = new ListNode(Integer.parseInt(numbers[0]));
        ListNode current = head;
        
        for (int i = 1; i < numbers.length; i++) {
            int num = Integer.parseInt(numbers[i]);
            current.next = new ListNode(num);
            current = current.next;
        }
        
        ListNode uniqueList = removeDuplicates(head);
        
        StringBuilder result = new StringBuilder();
        while (uniqueList != null) {
            result.append(uniqueList.val).append(" ");
            uniqueList = uniqueList.next;
        }
        
        System.out.println(result.toString().trim());
    }
    
    private static ListNode removeDuplicates(ListNode head) {
        if (head == null) {
            return null;
        }
        
        ListNode current = head;
        while (current != null && current.next != null) {
            if (current.val == current.next.val) {
                current.next = current.next.next;
            } else {
                current = current.next;
            }
        }
        
        return head;
    }
}

在代码中，我们首先将输入的一行数字按空格分隔成一个字符串数组。然后，我们根据数字数组创建链表，并使用`removeDuplicates()`方法删除重复的元素。最后，我们将去重后的链表转换为字符串，并打印输出。

希望能帮到您！如果您还有其他问题，请随时提问。

c语言给定两个元素有序（从小到大）的链表，要求将两个链表合并成一个有序（从小到大）链表，

可以按照以下方法实现：

1. 定义一个新的链表，表示合并后的有序链表。
2. 初始化指向两个链表头结点的指针 p1和p2。
3. 当p1和p2都不为空时，比较它们的值，将较小的结点加入新链表，并将指针指向下一个结点。
4. 如果p1已经为空，将p2剩余的结点加入新链表。
5. 如果p2已经为空，将p1剩余的结点加入新链表。
6. 返回新链表的头结点。

具体实现如下：

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

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

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    if (l1 == NULL) {  // 如果l1为空，返回l2
        return l2;
    }
    if (l2 == NULL) {  // 如果l2为空，返回l1
        return l1;
    }
    ListNode* p1 = l1;  // 指向l1的指针
    ListNode* p2 = l2;  // 指向l2的指针
    ListNode* newHead = NULL;  // 合并后链表的头结点
    ListNode* tail = NULL;     // 指向合并后链表的尾结点
    if (p1->val <= p2->val) {  // 找到新链表的头结点
        newHead = p1;
        tail = p1;
        p1 = p1->next;
    } else {
        newHead = p2;
        tail = p2;
        p2 = p2->next;
    }
    while (p1 != NULL && p2 != NULL) {  // 合并链表
        if (p1->val <= p2->val) {
            tail->next = p1;
            tail = p1;
            p1 = p1->next;
        } else {
            tail->next = p2;
            tail = p2;
            p2 = p2->next;
        }
    }
    if (p1 == NULL) {  // 将剩余的结点加入新链表
        tail->next = p2;
    }
    if (p2 == NULL) {
        tail->next = p1;
    }
    return newHead;
}

int main() {
    ListNode* l1 = (ListNode*) malloc(sizeof(ListNode));
    ListNode* l2 = (ListNode*) malloc(sizeof(ListNode));
    l1->val = 1;
    l1->next = (ListNode*) malloc(sizeof(ListNode));
    l1->next->val = 2;
    l1->next->next = (ListNode*) malloc(sizeof(ListNode));
    l1->next->next->val = 4;
    l1->next->next->next = NULL;
    l2->val = 1;
    l2->next = (ListNode*) malloc(sizeof(ListNode));
    l2->next->val = 3;
    l2->next->next = (ListNode*) malloc(sizeof(ListNode));
    l2->next->next->val = 4;
    l2->next->next->next = NULL;
    ListNode* newHead = mergeTwoLists(l1, l2);
    while (newHead != NULL) {
        printf("%d ", newHead->val);
        newHead = newHead->next;
    }
    printf("\n");
    return 0;
}

输出：1 1 2 3 4 4