利用栈实现单链表逆序的算法

以下是利用栈实现单链表逆序的算法：

1. 创建一个空栈。
2. 遍历单链表，将每个节点依次压入栈中。
3. 弹出栈顶节点，并将其链接到新的链表中。
4. 重复步骤3，直到栈为空。
5. 返回新的链表，即为逆序后的单链表。

示例代码如下所示：

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

def reverse_linked_list(head):
    stack = []
    current = head

    # 将链表节点压入栈中
    while current:
        stack.append(current)
        current = current.next

    # 弹出栈顶节点，并链接到新的链表中
    new_head = Node()
    current = new_head
    while stack:
        node = stack.pop()
        current.next = node
        current = current.next

    # 设置新链表的尾节点的next为None
    current.next = None

    return new_head.next

相关问题

利用栈实现单链表的逆序伪代码

以下是利用栈实现单链表逆序的伪代码：

1. 定义一个栈stack
2. 定义一个指针current指向链表的头节点
3. 遍历链表，将每个节点依次压入栈中，直到链表的末尾
   while current 不为空：
       将current节点压入栈中
       current指向下一个节点
4. 定义一个新的指针new_head指向栈顶节点，作为逆序后的链表的头节点
5. 定义一个指针temp指向new_head，用于遍历逆序后的链表
6. 弹出栈中的节点，将其作为temp的下一个节点，直到栈为空
   while stack 不为空：
       弹出栈顶节点，记为node
       temp的下一个节点指向node
       temp指向node
7. 将temp的下一个节点置为空，表示逆序后的链表的末尾
8. 返回new_head作为逆序后的链表的头节点

python写一个单链表逆序算法

以下是Python实现的单链表逆序算法：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def reverseList(head: ListNode) -> ListNode:
    prev = None
    curr = head
    while curr:
        next_node = curr.next
        curr.next = prev
        prev = curr
        curr = next_node
    return prev

这里我们定义了一个`ListNode`类来表示链表中的节点，每个节点由一个值`val`和一个指向下一个节点的指针`next`组成。`reverseList`函数接收一个链表的头节点`head`作为输入，返回一个逆序后的链表的头节点。

我们使用三个指针`prev`、`curr`和`next_node`来完成链表的逆序。初始时，`prev`指向`None`，`curr`指向头节点`head`，`next_node`指向`curr`的下一个节点。在循环中，依次将`curr`的`next`指针指向`prev`，然后更新`prev`、`curr`和`next_node`的值。当`curr`为空时，循环结束，此时`prev`指向原链表的尾节点，即逆序后的链表的头节点。最后返回`prev`即可。