【递归】反转链表

反转链表-递归及迭代实现

题目链接：反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例1:

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例2:

输入：head = [1,2]
输出：[2,1]

1.递归实现

视角一：从宏观角度

step1：我相信头结点后面的所有节点（图示蓝色方框），传入head->next，经过reverseList这个函数一定能完成逆置，且一定能返回最后一个节点！这个很重要，一定要相信这个函数能完成。

step2：最后就是收尾工作，将head->next（head的下一个节点）的next指向head；将head的next指向空；返回newhead。

step3：递归终止条件：空节点不递归，返回nullptr；叶子结点不递归，返回它本身head；综合来说，返回head即可。

最终代码实现如下：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr || head->next == nullptr) 
            return head;

        ListNode* newhead = reverseList(head->next); // 我相信head后面的所有节点都完成了逆置，并且返回尾节点
        head->next->next = head; // 让下一个节点的next指向head
        head->next = nullptr;
        return newhead;
    }
};

视角二：将链表看成一棵树

step1：将链表看成一棵树，对这棵树进行深度优先遍历。

ListNode* newhead = reverseList(head->next);

step2：当遍历到叶子结点时，返回尾节点newhead。

step3：当前函数栈帧结束后，返回到了上一层，上一层的head->next的next要指向head自己，head自己的next要指向空；这是一套相同的动作，返回给上一层之后也是要做的。

head->next->next = head; // 让下一个节点的next指向head
head->next = nullptr;

step4：当head走到节点1时，也是最后一层函数要结束的时候，最后就直接返回 newhead 即可。

时间复杂度： O(n)，n 为链表的长度。

空间复杂度： O(n)。递归调用函数会消耗栈空间，消耗栈空间的大小和递归调用函数的深度有关，当递归调用结束时，reverseList函数最多被调用 n 次。

2.迭代实现

n1和n2负责相互链接，即n2->next = n1;；但是n3和n2不能马上链接，因为链接了就找不到n3的后面节点了；所以n1，,2和n3要往后挪一步，使得n1和n2之间继续负责之前的工作（相互链接），n3其实是负责记录后面的节点，方便往后挪动。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr) return head;
        ListNode* n1 = nullptr, *n2 = head, *n3 = head->next;
        while(n3)
        {
            // 先让n1和n2链接
            n2->next = n1;
            // 再让n1 n2 n3往前移动一步
            n1 = n2;
            n2 = n3;
            n3 = n3->next;
        }
        n2->next = n1;
        return n2;
    }
};

时间复杂度： O(n)。

空间复杂度： O(1)。