本题要求实现一个函数，将给定的单链表逆转。

算法思路：

我们可以用三个指针来实现单链表的逆转操作：当前节点指针cur、前一个节点指针pre和后一个节点指针next。

1. 将当前节点cur指向链表的头结点。
2. 当cur不为空时，执行以下操作：
- 用next指针保存cur节点的下一个节点。
- 将cur节点的next指向pre节点。
- 将pre节点移到cur节点的位置。
- 将cur节点移到next节点的位置。
3. 遍历完整个链表之后，pre即为新的逆转后的头结点。

算法代码：

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

def reverseList(head: ListNode) -> ListNode:
    pre = None
    cur = head
    while cur:
        next = cur.next
        cur.next = pre
        pre = cur
        cur = next
    return pre

时间复杂度：O(n)。遍历整个链表只需要执行一次。

空间复杂度：O(1)。只需要常数级的空间来保存三个指针。

相关问题

本题要求实现一个函数，将给定的单链表逆转

### 回答1：
实现一个函数，将给定的单链表逆转，可以按照以下步骤进行：

1. 定义一个指针变量p，指向链表的头结点。
2. 定义一个指针变量q，指向p的下一个结点。
3. 将p的next指针指向NULL，表示p成为了新链表的尾结点。
4. 将p赋值给一个新的指针变量r，表示r指向当前链表的尾结点。
5. 将q的next指针指向p，将q插入到新链表的头部。
6. 将q赋值给p，表示p指向当前链表的头结点。
7. 重复步骤2-6，直到p指向NULL，表示链表已经逆转完成。

具体实现可以参考以下代码：

void reverseList(ListNode* head) {
    ListNode* p = head;
    ListNode* q = NULL;
    while (p != NULL) {
        q = p->next;
        p->next = NULL;
        ListNode* r = p;
        p = q;
        if (q != NULL) {
            q = q->next;
            r->next = head;
            head = r;
        }
    }
}

### 回答2：
单链表是一种常用的数据结构，它由多个节点依次链接而成，每个节点包含两个部分，一个是保存数据的元素，另一个是指向下一个节点的指针。由于单链表只能单向遍历，因此当需要逆序遍历时，就需要将单链表进行逆转。

实现一个将给定的单链表逆转的函数，可以采用头插法遍历单链表实现。具体操作如下：

1. 定义一个新的空链表，作为逆转后的链表头；
2. 遍历给定的单链表，将每个节点分离出来，并将其作为头节点，插入逆转后的链表头；
3. 返回逆转后的链表头。

具体的代码实现如下（C++）：

ListNode* reverseList(ListNode* head) {
    ListNode* newHead = nullptr; // 定义新的空链表头
    while(head) {
        ListNode* nextNode = head->next; // 保存下一个节点
        head->next = newHead; // 头节点插入新链表头
        newHead = head; // 更新新链表头
        head = nextNode; // 移动到下一个节点
    }
    return newHead; // 返回逆转后的链表头
}

需要注意的是，在遍历单链表时，需要使用一个额外的指针nextNode来保存下一个节点，因为一旦将头节点插入新链表头之后，原链表的链接关系就被打破了，直接使用head->next会导致错误。同时，当原单链表为空时，直接返回nullptr即可。

### 回答3：
本题要求实现一个函数，将给定的单链表逆转。对于此题，我们需要遍历链表，将链表的每个节点指向它前面的节点，最后将头节点指向空节点。

我们可以使用三个指针来实现链表的逆转：一个指向当前节点，一个指向前一个节点，一个指向后一个节点。我们先让当前节点指向头节点，前一个节点指向空节点。接下来，我们遍历当前链表，每次将当前节点的下一个节点指向前一个节点，并将前一个节点指向当前节点，当前节点指向后一个节点。

最后，我们需要将头节点指向空节点，这样就完成了链表的逆转。在代码实现中，我们需要特别注意临界条件，例如空链表和只有一个节点的链表。

代码示例：

Node* reverseList(Node *head){
    if(head==NULL || head->next==NULL) return head; // 空链表或只有一个节点的链表
    Node *prev=NULL, *current=head, *nextNode=head->next;
    while(current!=NULL){
        nextNode=current->next;
        current->next=prev;
        prev=current;
        current=nextNode;
    }
    head=prev;
    return head;
}

以上就是实现单链表逆转的一种方法，希望对大家有所帮助。

实现一个函数，将给定的单链表逆转

在编程中，反转单链表是一个常见的操作，通常会递归或迭代的方式实现。这里我将提供一种基于迭代的Python代码示例：

# 定义链表节点
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def reverseList(head):
    # 初始化两个指针，prev表示前一个节点，curr表示当前节点
    prev = None
    curr = head
    
    # 遍历整个链表
    while curr is not None:
        # 记录当前节点的下一个节点
        next_node = curr.next
        # 将当前节点指向prev
        curr.next = prev
        
        # 移动指针到下一个节点
        prev = curr
        curr = next_node
    
    # 返回新的头节点，即原链表的尾部
    return prev

这个函数接受一个链表的头节点作为输入，通过改变节点之间的连接，使得原来的顺序变成反向。