已知一个不带头结点的单链表head，结点结构位Node。写出一个同样的算法，删除链表中值相同的结点

为了删除给定单链表中值相同的节点，可以遍历整个链表，并将当前节点与其后面的节点逐个比较，如果发现有连续两个节点值相等，则只保留第一个节点，跳过第二个。以下是Python的一个示例实现：

class Node:
    def __init__(self, value=None):
        self.value = value
        self.next = None

def delete_duplicates(head):
    if head is None or head.next is None:
        return head

    current = head
    while current.next is not None:
        if current.value == current.next.value:
            # 删除当前节点的下一个节点
            next_node = current.next.next
            current.next = next_node
        else:
            # 更新当前节点为下一个节点，继续检查
            current = current.next

    return head

这个函数会遍历链表，遇到值相同的节点就将其从链表中删除。注意，这里假设`value`字段是唯一的标识符，如果链表中有多个连续的相同值，函数只会删除第一个。

相关问题

已知一个不带头结点的单链表head中存放了一组整型数，构造算法，删除链表中值最大的结点

要从单链表中删除值最大的节点，你可以按照以下步骤构建算法：

1. **初始化最大值变量**：首先，创建一个变量 `maxNode` 和一个 `currentMax`，用于保存当前找到的最大值以及指向它的指针。假设 `maxNode` 初始设为 `NULL`，`currentMax` 设为 `head`。

2. **遍历链表**：从头开始遍历链表，用两个指针 `current` 来表示当前节点。
- a. 检查 `current` 的值是否大于 `currentMax` 的值。如果是，则更新 `maxNode` 为 `current`，并将 `currentMax` 更新为 `current`。
- b. 否则，只需移动 `currentMax` 到下一个节点即可。

3. **删除最大值节点**：当遍历完链表后，如果 `maxNode` 不是 `NULL`，说明找到了最大值。此时，可以设置 `maxNode` 的下一个节点为 `maxNode->next`，然后释放 `maxNode` 的内存（`free(maxNode)`），因为已经找到了它的替换节点。

4. **返回链表头部**：最后返回 `currentMax` 所指的节点，作为新链表的头。

下面是伪代码形式的描述：

Node* deleteLargest(head Node* head) {
    if (head == NULL || head->value > currentMax->value) {
        maxNode = head;
        currentMax = head;
    } else {
        currentMax->next = currentMax->next;
    }

    while (currentMax->next != NULL) {
        if (currentMax->next->value > currentMax->value) {
            maxNode = currentMax->next;
        }
        currentMax = currentMax->next;
    }

    // 删除最大节点
    if (maxNode != NULL) {
        free(maxNode);
    }

    return currentMax;
}

已知一个不带头结点的单链表head中存放了一-组整型数，构造算法，删除链表中值最大的结点

要删除链表中值最大的节点，你需要遍历链表两次：一次找到最大值，另一次找到该最大值对应的节点并删除它。这里有一个简单的步骤：

1. **初始化变量**：设置两个指针 `maxNode` 和 `current`，它们都指向 `head`。同时定义两个变量 `maxVal`（初始为负无穷）和 `maxIndex`（记录最大值的位置）。

int maxVal = INT_MIN;
Node* maxNode = head;
Node* current = head;

2. **寻找最大值**：遍历链表，如果当前节点的值大于 `maxVal`，则更新 `maxVal` 和 `maxNode`。

while (current != nullptr) {
    if (current->value > maxVal) {
        maxVal = current->value;
        maxNode = current;
    }
    current = current->next;
}

3. **删除最大节点**：现在你知道了最大值所在的节点 `maxNode`，你可以从 `maxNode` 的前一个节点开始，将 `maxNode` 设置为 `nullptr` 并移动前驱节点到 `maxNode` 的位置，从而删除它。

if (maxNode == head) { // 如果最大节点就是头节点
    head = head->next;
} else {
    Node* prevMaxNode = maxNode->prev; // 前驱节点
    prevMaxNode->next = maxNode->next; // 更新前驱节点的下一个节点
}
delete maxNode; // 释放最大节点的空间