1、链表反转之完全反转

链表的反转是非常经典的一种算法题，一般有三种不同的类型，分别是：

1、完全反转；

2、固定区间反转；

3、每k个一组反转

在本章我会介绍第一种即完全反转的算法（注：我不仅仅只是给出时间复杂度和空间复杂度最低的算法，有一些容易理解的算法比如利用栈的特性来进行反转等等我也会给出，可以帮助大家从不同的视角理解问题，但是最优解我一般会给出标注、具体示例以及对应的Java代码）

1.1 使用栈来解决

        使用栈来完全反转一个链表的思路其实是很直观的。我们都知道链表的特性是先进后出，而栈的特性是后进先出。所以，我们可以通过以下步骤来实现：

1. 遍历链表，将每个节点都压入栈中。
2. 从栈中弹出每个节点，并重新构建链表。

具体的实现步骤也很简单，分为以下四步：

1. 初始化一个空的栈。
2. 遍历链表，将每个节点压入栈中。
3. 创建一个新的空链表或使用原链表的头节点开始重建。
4. 当栈不为空时，弹出栈顶元素，并将其添加到新链表的末尾。

        使用栈来反转链表的方法比直接操作指针更加直观，但需要额外的 O(n) 空间来存储栈。这种方法在空间复杂度上不如直接使用指针操作，但对于初学者来说，可能更容易理解和实现。

1.2 使用指针来解决（最优解）

        使用指针操作完全反转一个链表是一个经典方法，既简洁又高效。这里，我们使用三个指针: prev, current, 和 next。

基本思路如下：

1. 初始化三个指针：prev 设置为 None（因为在反转的头部，你希望它指向None），current 设置为 head，以及 next。
2. 在每次迭代中，你首先保存当前节点的下一个节点（因为你会更改 current 的下一个指针），然后更改 current 的下一个指针以指向 prev。然后，前移 prev 和 current。
3. 当你处理完整个链表后，head 将指向链表的最后一个节点。为了使其指向反转链表的第一个节点，你返回 prev 作为新的头节点。

示例：假设我们有一个链表

[1] -> [2] -> [3] -> [4] -> [5]

我们的目标是反转整个链表，使其变为 

 None <- [1] <- [2] <- [3] <- [4] <- [5]

 使用指针操作的步骤如下：

• 初始化三个指针：

  • prev = None
  • current = 1 (链表的头节点)
  • next （这个稍后会被设置）

• 开始第一次迭代:

  • next = 2 (保存 current 的下一个节点)
  • 将 current.next 指向 prev (现在，1 指向 None)
  • prev 前移，变为 1
  • current 前移，变为 2

现在的链表结构：

 None <- [1] [2] -> [3] -> [4] -> [5]

• 开始第二次迭代:
  • next = 3
  • 将 current.next 指向 prev (现在，2 指向 1)
  • prev 前移，变为 2
  • current 前移，变为 3

现在的链表结构：

None <- [1] <- [2] [3] -> [4] -> [5]

你可以继续这个过程，直到 current 为 None。

完成后，链表会是这样的：

  None <- [1] <- [2] <- [3] <- [4] <- [5]

由于 prev 现在指向链表的最后一个节点（也是反转后的新头节点），所以返回 prev。

        这种方法的时间复杂度为 O(n)，其中 n 是链表的长度。空间复杂度为 O(1)，因为我们只使用了几个额外的指针，而没有使用额外的数据结构，如栈。因此这种方法在时间和空间上都很高效。

附Java代码：

public class ListNode {
    int val;
    ListNode next;
    
    ListNode() {}
    
    ListNode(int val) { this.val = val; }
    
    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

public class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode current = head;
        ListNode next = null;
        
        while (current != null) {
            next = current.next;   // 保存当前节点的下一个节点
            current.next = prev;   // 更新当前节点的 next 指针
            prev = current;        // 前移 prev 指针
            current = next;        // 前移 current 指针
        }
        
        return prev;  // 返回新的头节点
    }
}

 1.1 递归求解

        使用递归来反转链表的基本思想其实就是：不断地将链表“缩短”，直到只剩一个节点或为空。然后，在递归返回的过程中，将链表的方向逐渐反转。

具体来说，考虑链表 

[1] -> [2] -> [3] -> [4] -> [5]

1. 如果我们递归调用到链表的最后一个节点（即 5），那么这个节点就是反转后的头节点。
2. 当递归返回到 4，我们想要 5 指向 4，即 5 -> 4。这可以通过设置 4 的下一个节点的下一个节点来指向 4 自己实现，即 4.next.next = 4。
3. 同样地，当递归返回到 3 时，我们希望 4 -> 3，所以我们设置 3.next.next = 3。

继续这个过程，直到链表完全反转。
        递归方法的优势在于它提供了一个非常直观和简洁的解决方案。但需要注意，如果链表非常长，递归方法可能会因为深度过大导致栈溢出。