21-剑指 Offer 24. 反转链表

题目

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

限制：0 <= 节点个数 <= 5000

---

思路1

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

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

---

代码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,指向两个节点。

---

代码2

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

递归法。

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

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

---

代码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

利用栈的特点解此题。

---

代码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;
}