反转链表

题目：

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

示例 1：

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

示例 2：

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

示例 3：

输入：head = []
输出：[]

提示：

    链表中节点的数目范围是 [0, 5000]
    -5000 <= Node.val <= 5000

进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

---

方法1：

思路：

头插法：按照节点出现的顺序倒序输出。

不修改原链表的结构，新建一个链表。边遍历原链表，边新建一个新链表将节点进行头插，返回新链表的头节点。

代码：

/**
 * Definition for singly-linked list.
 * 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; }
 * }
 */

class Solution{
    public ListNode reverseList(ListNode head){
        //边界条件判断
        if(head == null || head.next == null){
             return head;
        }
        //新建链表的头节点
        ListNode newHead = null;
        //遍历原链表，取出值，新建节点，头插入新链表
        while(head != null){
           //原链表的头节点
           ListNode node = new ListNode(head.val);
           //将原链表的头节点头插入新链表的头节点之后
           node.next = newHead;
           //将newHead变为node,前移
           newHead = node;
           //node继续向后扫描原链表节点
           head = head.next;
        }
        return newHead;
    }
}

---

方法2：

思路：

若要求空间复杂度为O(1)，无法新建节点完成。可原地修改原链表，将相邻两个节点的指向互换，需要两个遥控器，prev和cur,指向两个节点。

代码：

public ListNode reverseList(ListNode head){
    //判断边界条件
    if(head == null || head.next == null){
        return head;
    }
    //prev指向空开始，因为反转后的链表head.next = null（此处用不用虚拟头节点无所谓）
    ListNode prev = null;
    ListNode cur = head;
    //当cur指向空时，所有相邻节点的反转结束，此时prev恰好就是反转后链表的头节点
    while(cur != null){
       //当cur.next = prev时，确实修改了两个节点的指向，但丢了cur的下一个节点
       //使用next暂存下一个要处理的节点
       ListNode next = cur.next;
       cur.next = prev;
       prev = cur;
       cur = next;
    }
    return prev;
 }
       

---

方法3：

思路：

递归法。

方法功能：传入一个链表，就能将此链表进行反转，并且返回反转后的链表的头节点。

只知道头节点，就把第二个节点到最后一个节点的反转工作交给方法执行。

代码：

public ListNode reverseList(ListNode head){
     //判断边界条件
     if(head == null || head.next == null){
         return head;
     }
     //此时第二个节点secNode以及之后的节点的反转工作交给reverseList()这个方法执行
     //并且返回的链表头就是最终的返回值
     ListNode secNode = head.next;
     ListNode newHead = reverseList(head.next);
     secNode.next = head;
     head.next = null;
     return newHead;
}

---

方法4：

思路：

利用栈的特点解此题。

---

代码

public ListNode reverseList(ListNode head){
    //创建一个栈
    Stack <ListNode> stack = new Stack<>();
    //若链表头节点不为空，将链表节点依次入栈
    while (head != null){
       stack.push(head);
       head = head.next;
    }
    //准备将栈中节点依次出栈
    //判断栈是否为空
    if(stack.isEmpty()){
       return null;
    }
    //将栈的栈顶节点作为反转后链表的头节点
    ListNode node = stack.pop();
    //用dummy暂存此节点
    ListNode dummy = node;
    //将栈中其他节点依次出栈，并连接成新的链表，即完成链表反转
    while(!stack.isEmpty()){
       //tempNode暂存当前栈的栈顶元素
       ListNode tempNode = stack.pop();
       //将已经出栈的节点与即将出栈的栈顶节点相连
       node.next = tempNode;
       //将node定位至新反转链表的最后一个节点
       node = node.next;
     }
     //避免成环
     node.next = null;
     return dummy;
}