设有一个表头指针为h 的单链表。试设计一个算法，通过遍历一 趟链表，将链表中所有结点的链接方向逆转，要求逆转结 果链表的表头指针h 指向原链表的最后一个结点。

要实现这个功能，可以采用迭代的方式来逆转单链表的方向。具体的步骤如下：

1. 定义两个指针，`prev` 和 `curr`，初始时都指向 `h`（即链表的第一个节点）。

2. `prev` 初始化为 `NULL`，因为反转后的第一个节点将是原来的最后一个节点。

3. 使用 `while` 循环，只要 `curr` 不为空（即链表未结束），就执行以下操作：
- 将当前节点的 `next` 指针赋值给临时变量 `temp`，即将 `curr` 的下一个节点保存起来。
- 将 `curr` 的 `next` 指针更新为 `prev`，也就是逆转了连接。
- 更新 `prev` 和 `curr`，让它们分别向前移动一位：`prev = curr` 和 `curr = temp`。

4. 当 `curr` 为空时，`prev` 就会指向新的表头节点，即原链表的最后一个节点。此时跳出循环。

5. 最后，设置 `h` 指向 `prev`，即新链表的表头。

下面是伪代码形式的实现：

prev = NULL
curr = h

while curr is not NULL:
    next_node = curr.next
    curr.next = prev
    prev = curr
    curr = next_node

h = prev

这样，链表就被成功地逆转了，`h` 指向的是原链表的最后一个节点。

相关问题

设有一个表头指针为L的单链表。试设计一个算法，通过遍历一趟链表，将链表中所有结点按逆序链接。

为了实现这个功能，我们可以采用迭代的方式遍历链表，并在遍历过程中调整节点之间的引用。这里是一个简单的步骤描述：

1. 初始化两个指针，分别命名为 `prev` 和 `current`，初始都设置为 `NULL`。`prev` 用于存储当前节点的前一个节点，而 `current` 则指向当前正在处理的节点，即链表头部的 `L`。

2. 当 `current` 不为 `NULL` 时，执行以下操作：
a. 将 `current` 的下一个节点赋值给临时变量 `next`，保存当前节点的后继节点。
b. 将 `current` 的指向前驱设为 `prev`，使其反转链接。
c. 更新 `prev` 指向 `next`，即将 `prev` 移动到下一个位置。
d. 将 `current` 赋值为 `next`，继续处理下一位节点。

3. 遍历结束后，`current` 就会变成 `NULL`，此时 `prev` 就是指向原链表尾部的节点，它之前的所有节点已经被逆序连接。所以，只需将 `prev` 指向的节点设置为新的链表头 `L`，就可以完成整个链表的逆序。

以下是伪代码形式的算法：

L = 单链表头
prev = NULL
current = L

while current != NULL:
    next = current.next
    current.next = prev  # 反转当前节点的指向
    prev = current       # 更新前驱节点
    current = next       # 继续遍历

if prev != NULL:  # 如果不是空链表
    L = prev  # 新的头节点是之前的尾节点

设有一个表头指针为 h 的单链表。试设计一个算法，通过遍历一趟链 表，将链表中所有结点的链接方向逆转，如图2.2所示。要求逆转结果链 表的表头指针 h 指向原链表的最后一个结点

要实现这个功能，你可以按照以下步骤设计算法：

1. 定义两个指针，`prev` 和 `current`，初始化时，`prev` 设置为 `NULL`，`current` 设置为链表的头节点 `h`。

2. 创建一个新的临时指针 `next`，用于存储 `current` 的下一个节点。

3. 开始遍历链表：

   while current is not None:  # 当 current 不为空时
       temp = current.next  # 备份 current 的下一个节点
       current.next = prev  # 更新 current 的下一个节点为 prev（即将其反向）
       prev = current  # 移动 prev 到 current
       current = temp  # 移动 current 到下一个节点

4. 链表遍历结束后，链表的头节点 `h` 就变成了原链表的尾节点，所以最后更新 `head` 为 `prev`。

这是基于伪代码的Python实现，但请注意，这里的语法是Python，如果你是在C/C++环境中，会有所不同。以下是C++版本的代码实现：

void reverseList(Node* &h) {
    Node* prev = nullptr;
    Node* current = h;

    // 遍历链表
    while (current != nullptr) {
        Node* nextTemp = current->next;
        current->next = prev;
        prev = current;
        current = nextTemp;
    }

    // 更新头节点为原链表尾节点
    h = prev;
}

其中，`Node*` 是链表节点的定义，`&h` 表示传入的链表头指针的地址。