一个按元素值从小到大排列的单向链表A:1,2,3,4,4,5,5,6,7,8,9,9,9,10,请编写算法删除表内元素值相同的链点(只保留其中一个)。

定义一个指针p指向链表的第一个节点，通过遍历链表的方式，找到链表中相邻两个节点元素值相同的情况，并删除其中一个节点。具体步骤如下：
1. 如果链表为空或只有一个节点，则直接返回链表。
2. 定义两个指针prev和cur，分别指向当前节点和下一个节点。
3. 遍历链表，判断cur节点与下一个节点的元素值是否相同。
4. 如果相同，删除下一个节点，并将cur指向下一个节点的下一个节点。
5. 如果不相同，将prev指向cur，cur指向下一个节点。
6. 重复步骤3-5，直到cur指向链表的最后一个节点。
7. 返回链表。

以下是实现该算法的示例代码：

def remove_duplicates(head):
    if head is None or head.next is None:
        return head
    
    prev = head
    cur = head.next
    
    while cur is not None:
        if cur.data == cur.next.data:
            cur.next = cur.next.next
        else:
            prev = cur
            cur = cur.next
    
    return head

请注意，在上述代码中，我使用了data表示链表节点的元素值。你可以根据实际情况进行修改。

相关问题

5 //链表总元素数 1 2 3 4 5 //链表各元素

如果你想用 linearList.h 来创建一个链表对象，并且向其中插入这 5 个元素，可以按照以下步骤进行操作：

1. 引入头文件

#include "linearList.h"

2. 定义链表对象

定义一个链表对象，使用链表来实现：

LinearList<int> myList; // 定义一个空的链表对象

3. 向链表中插入元素

使用 `myList.insert()` 函数向链表中插入元素：

myList.insert(0, 1); // 在链表的第0个位置插入元素1
myList.insert(1, 2); // 在链表的第1个位置插入元素2
myList.insert(2, 3); // 在链表的第2个位置插入元素3
myList.insert(3, 4); // 在链表的第3个位置插入元素4
myList.insert(4, 5); // 在链表的第4个位置插入元素5

4. 使用链表

使用链表中的元素进行相应的操作：

for (int i = 0; i < myList.length(); i++) {
    cout << myList.get(i) << " "; // 输出链表中的每个元素
}

以上就是使用 linearList.h 创建链表并向其中插入元素的基本步骤，你可以根据自己的需求进行调整。

头插法创建链表 输入： 4 1 2 3 4 5 6 7 8 输出： 7 8 5 6 3 4 1 2

好的，这是一个关于头插法创建链表的问题。我来解答一下。

首先，头插法是指在链表头部插入新节点，新节点成为链表的新头部。这种方法可以方便地实现链表的逆序，并且时间复杂度为 O(n)。

下面是使用头插法创建链表并逆序的代码：

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

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

Node* createList() {
    Node* head = NULL;
    Node* p = NULL;
    int n, i, x;

    scanf("%d", &n);

    for (i = 0; i < n; i++) {
        scanf("%d", &x);
        p = (Node*)malloc(sizeof(Node));
        p->data = x;
        p->next = head;
        head = p;
    }

    return head;
}

void printList(Node* head) {
    Node* p = head;

    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }

    printf("\n");
}

void reverseList(Node** head) {
    Node* prev = NULL;
    Node* curr = *head;
    Node* next = NULL;

    while (curr != NULL) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }

    *head = prev;
}

int main() {
    Node* head = createList();

    printList(head);

    reverseList(&head);

    printList(head);

    return 0;
}

在 createList 函数中，先读入链表的长度 n，然后依次读入每个节点的值 x，创建新节点并将其插入到链表头部，最后返回链表的头指针。

在 reverseList 函数中，使用三个指针 prev、curr 和 next 分别表示当前节点的前一个节点、当前节点和当前节点的后一个节点，依次将当前节点的 next 指针指向前一个节点，然后将 prev、curr 和 next 分别向后移动一位，直到 curr 指向链表的最后一个节点为止。最后将 head 指针指向 prev，完成链表的逆序。

最后在主函数中，先打印原始链表，然后调用 reverseList 函数逆序链表，最后再打印逆序后的链表。