BM1 反转链表

描述
给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0\leq n\leq10000≤n≤1000
要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n) 。

如当输入链表{1,2,3}时，
经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。
以上转换过程如下图所示：

示例1

输入： {1,2,3}
返回值： {3,2,1}

示例2

输入： {} 复制
返回值： {} 复制
说明： 空链表则输出空

题解思路
将链表反转，就是将每个表元的指针从向后变成向前，那我们可以遍历原始链表，将遇到的节点一一指针逆向即可。指针怎么逆向？不过就是断掉当前节点向后的指针，改为向前罢了。

cur.next = pre

具体做法：

• step 1：优先处理空链表，空链表不需要反转。
• step 2：我们可以设置两个指针，一个当前节点的指针，一个上一个节点的指针（初始为空）。
• step 3：遍历整个链表，每到一个节点，断开当前节点与后面节点的指针，并用临时变量记录后一个节点，然后当前节点指向上一个节点，即可以将指针逆向。
• step 4：再轮换当前指针与上一个指针，让它们进入下一个节点及下一个节点的前序节点。
  图示：
  
  Java实现代码：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    
    public ListNode ReverseList(ListNode head) {
    
        //处理空链表
        if(head == null) 
            return null;
        ListNode cur = head;
        ListNode pre = null;
        while(cur != null){
    
            //断开链表，要记录后续一个
            ListNode temp = cur.next; 
            //当前的next指向前一个
            cur.next = pre; 
            //前一个更新为当前
            pre = cur; 
            //当前更新为刚刚记录的后一个
            cur = temp; 
        }
        return pre;
    }
}

C++实现代码：

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
    
public:
    ListNode* ReverseList(ListNode* pHead) {
    
        //处理空链表
        if(pHead == NULL)
            return NULL;
        ListNode* cur = pHead;
        ListNode* pre = NULL;
        while(cur != NULL){
    
            //断开链表，要记录后续一个
            ListNode* temp = cur->next; 
            //当前的next指向前一个
            cur->next = pre; 
            //前一个更新为当前
            pre = cur; 
            //当前更新为刚刚记录的后一个
            cur = temp; 
        }
        return pre;
    }
};

Python实现代码：

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param head ListNode类 
# @return ListNode类
#
class Solution:
    def ReverseList(self , head: ListNode) -> ListNode:
        #处理空链表
        if not head:
            return None
        cur = head
        pre = None
        while cur:
            #断开链表，要记录后续一个
            temp = cur.next 
            #当前的next指向前一个
            cur.next = pre
            #前一个更新为当前
            pre = cur 
            #当前更新为刚刚记录的后一个
            cur = temp
        return pre

复杂度分析：

• 时间复杂度：O(n)O(n)O(n)，遍历链表一次，一次循环
• 空间复杂度：O(1)O(1)O(1)，常数级变量，无额外辅助空间使用