11-链表练习-LeetCode206反转链表

题目

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

    链表中节点的数目范围是 [0, 5000]
    -5000 <= Node.val <= 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) {
            //node为原链表节点
            ListNode node = new ListNode(head.val); 
            //将原链表节点头插入新链表中
            node.next = newHead; 
            //新链表前移
            newHead = node;
            //原链表后移
            head = head.next;
        }
        return newHead;
    }
}

---

思路2：原地修改链表

• 要求空间复杂度为O(1)，说明无法新建链表来处理，而需要原地修改链表结构。
• 将相邻2个节点的指向互换，需要2个引用分别指向2个节点：prev（prev从null开始）和cur。
• 而当cur.next = prev时，确实修改了2个节点的指向，但丢了cur的下一个节点->因此需要next指针暂存一下cur的下一个节点。
• 当cur指向空时，说明所有相邻节点已经全部处理完毕。
• 反转之后链表的头节点恰好就是prev引用。
• 注：因为prev从指向null开始，所以用不用虚拟头节点都行。

---

代码2

/**
 * 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 prev = null;
        ListNode cur = head;
        while(cur != null) {
            ListNode next = cur.next;
            cur.next = prev;
            prev = cur;
            cur = next;
        }
        return prev;
    }
}

---

思路3：递归法

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

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

---

代码3

/**
 * 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;
        }

        //此时将第二个节点以及之后的节点的反转工作交给reverseList()执行，并且返回的链表头就是最终的返回值
        ListNode secNode = head.next;
        ListNode newHead = reverseList(head.next);
        secNode.next = head;
        head.next = null;
        return newHead;
    }
}