解题思路

  1. 使用三个指针：

    • prev：指向前一个节点
    • curr：指向当前节点
    • next：指向下一个节点

  2. 反转步骤：

    • 保存当前节点的下一个节点(next = curr.next)
    • 反转当前节点的指针(curr.next = prev)
    • 移动prev和curr指针
      • prev = curr
      • curr = next

  3. 特殊情况处理：

    • 空链表：直接返回null
    • 单节点链表：直接返回该节点

代码

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        // 如果链表为空或只有一个节点，直接返回
        if (!pHead || !pHead->next) {
            return pHead;
        }
        
        ListNode* prev = nullptr;
        ListNode* curr = pHead;
        ListNode* next = nullptr;
        
        while (curr) {
            // 保存下一个节点
            next = curr->next;
            // 反转当前节点的指针
            curr->next = prev;
            // 移动prev和curr指针
            prev = curr;
            curr = next;
        }
        
        return prev;
    }
};

public class Solution {
    public ListNode ReverseList(ListNode head) {
        // 如果链表为空或只有一个节点，直接返回
        if (head == null || head.next == null) {
            return head;
        }
        
        ListNode prev = null;
        ListNode curr = head;
        ListNode next = null;
        
        while (curr != null) {
            // 保存下一个节点
            next = curr.next;
            // 反转当前节点的指针
            curr.next = prev;
            // 移动prev和curr指针
            prev = curr;
            curr = next;
        }
        
        return prev;
    }
}

class Solution:
    def ReverseList(self, head):
        # 如果链表为空或只有一个节点，直接返回
        if not head or not head.next:
            return head
            
        prev = None
        curr = head
        
        while curr:
            # 保存下一个节点
            next = curr.next
            # 反转当前节点的指针
            curr.next = prev
            # 移动prev和curr指针
            prev = curr
            curr = next
            
        return prev

算法及复杂度分析

  • 算法：链表的基本操作

  • 时间复杂度：

    • 只需要遍历一次链表
    • 是链表的长度

  • 空间复杂度：

    • 只使用了三个指针变量
    • 不需要额外的存储空间

这个解法的优点是：

  1. 实现简单直观
  2. 空间复杂度为
  3. 只需要一次遍历
  4. 不需要额外的数据结构