01链表反转

一、反转链表

反转链表

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

示例:

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

限制：

0 <= 节点个数 <= 5000

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */

方法一：迭代

这也是很多人在第一时间想到的方法，简单来说就是把链表的每一个引用逐个反转。节点遍历整个链表时，将当前节点的后继指向父节点。

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre=null;
        ListNode cur=head;
        while(cur!=null){
            ListNode nex=cur.next;
            cur.next=pre;
            pre=cur;
            cur=nex;
        }

        return pre;
    }
}

当修改节点后继时，必然会使一条链表断裂成两条，所以必须要另外声明一个pre节点和一个nex节点记录断裂开的两条链表。

方法二：递归

具体思路是把头节点后的所有节点看为一个整体，整个算法的任务就可以简化为将头节点与后继的反转，只需逐层递归实现即可。

class Solution {
    
    public ListNode reverseList(ListNode head) {
        if(head==null)
            return null;

        if(head.next==null)
            return head;

        ListNode newHead = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        
        return newHead;
    }
}

对于递归算法，最重要的就是明确递归函数的定义。

上框代码中reverseList函数定义为：
输入一个头节点head，将以head为头节点的链表反转，并返回反转后的链表的头节点。

最重要的一点：不要让自己的思维跳进递归里，要根据函数的定义，弄清递归函数会产生什么结果。

理解之后就可以进一步深入了。

二、反转链表前N个节点

如果我们要仅使前N个节点反转，其后节点顺序和位置不变。

即实现如下函数：

// 将链表的前 n 个节点反转（n <= 链表长度）
ListNode reverseN(ListNode head, int n)

我们的解题思路和整个链表反转差不多，只是整个链表的反转尾节点会指向null；而前N反转相当于把这些节点单独看成一条链表，只是最后的尾节点指向了剩余节点。

ListNode successor = null; //后驱节点

//反转以head为起点的n个节点，返回新的头节点
ListNode reverseN(ListNode head, int n){
    if(n==1){
        //记录第n+1个节点
        successor = head.next;
        return head;
    }
    // 以head.next为起点，需要反转前n-1个节点
    ListNode last = reverseN(head.next, n-1);
    head.next.next = head;
    // 反转后的head节点和后面的节点连起来
    head.next = successor;
    return last;
}

总结

递归相对于迭代，较为难理解，处理的技巧：不要跳进递归，而是利用明确的定义来实现算法逻辑。