【链表】206. Reverse Linked List; 92. Reverse Linked List II;25. Reverse Nodes in k-Group

参考：labuladong 递归反转链表的一部分

labubadong 如何k个一组反转链表

问题：

206.链表反转。

Example:

Input: 1->2->3->4->5->NULL
Output: 5->4->3->2->1->NULL

　　

92.指定区间链表反转。

Note: 1 ≤ m ≤ n ≤ length of list.

Example:

Input: 1->2->3->4->5->NULL, m = 2, n = 4
Output: 1->4->3->2->5->NULL

　　

25. 每连续k个元素进行反转。

Example 1:
Input: head = [1,2,3,4,5], k = 2
Output: [2,1,4,3,5]

Example 2:
Input: head = [1,2,3,4,5], k = 3
Output: [3,2,1,4,5]

Example 3:
Input: head = [1,2,3,4,5], k = 1
Output: [1,2,3,4,5]

Example 4:
Input: head = [1], k = 1
Output: [1]
 
Constraints:
The number of nodes in the list is in the range sz.
1 <= sz <= 5000
0 <= Node.val <= 1000
1 <= k <= sz

　　 

解法：Recursion（递归）Iteration（迭代）

206.

1.递归获得2～6，反转后的结果。

2.将2->next指针，指向1: 

由于原来1->next=2，因此 (1->next)->next = 1

3.将1->next指向NULL

 

 

BASE：

只有一个节点 or 0个节点，return head

代码参考：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    //1->reverseList(2<-3<-4<-5)
    ListNode* reverseList(ListNode* head) {
        //base
        if(!head || !head->next) return head;
        //recursion
        ListNode* newhead = reverseList(head->next);
        //OPT
        head->next->next = head;
        head->next = nullptr;
        return newhead;
    }
};

 

92.

先解决，如何反转前n个节点。

reverseN(ListNode* head, int n)

相较于206，多了第n个节点之后的，不需要反转的节点successor

因此，比206多出的处理：

• ★BASE：
  • 记录successor节点，n==1的时候，只剩一个节点
  • successor = head->next
• recursion后的　★OPT：
  • head->next=successor

即，代码为：

    ListNode* reverseN(ListNode* head, int n) {
        //base
        if(n==1) {
            successor = head->next;//★BASE
            return head;
        }
        //recursion
        ListNode* newhead = reverseN(head->next, n-1);
        //OPT
        head->next->next = head;
        head->next = successor;//★OPT
        return newhead;
    }

 

接下来，解决 从第m个开始，

递归到m==1，则变成上面的问题，直接调用reverseN即可。

其他情况，依次递归，不用更改任何指针。

⚠️ 注意：从第0个移动到第m个时的递归中，

返回值：当前的新头。所以，head->next=上次递归的结果。

代码为：

    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(!head || !head->next) return head;
        if(m==1) return reverseN(head, n);
        head->next = reverseBetween(head->next, m-1, n-1);
        return head;
    }

 

代码参考：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* successor;
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(!head || !head->next) return head;
        if(m==1) return reverseN(head, n);
        head->next = reverseBetween(head->next, m-1, n-1);
        return head;
    }
    ListNode* reverseN(ListNode* head, int n) {
        //base
        if(n==1) {
            successor = head->next;
            return head;
        }
        //recursion
        ListNode* newhead = reverseN(head->next, n-1);
        //OPT
        head->next->next = head;
        head->next = successor;
        return newhead;
    }
};

 

25. 

用迭代（Iteration）的方法实现[a,b)的反转

如下图，反转 [1,NULL)

 

 

    ListNode* reverse(ListNode* a, ListNode* b) {
        ListNode *cur = a, *pre = NULL, *nxt = a;
        while(cur!=b) {
            nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }

再用递归，求出第一组[a,b)反转后，连接到后面[b,...)已经反转完成的所有。

如下图k=2，[1,3)

 ⚠️ 注意：如果不足k个元素，则不进行反转。

    ListNode* reverseKGroup(ListNode* head, int k) {
        if(!head) return head;
        ListNode *a=head, *b=head;
        for(int i=0; i<k; i++) {
            if(b==NULL) return head;//不足k个元素，不进行反转
            b = b->next;
        }
        //反转[a,b)
        ListNode* newhead = reverse(a, b);
        //连接反转后的[a,b)，和反转的后面所有元素[b,...)
        a->next = reverseKGroup(b, k);
        return newhead;
    }

完整代码参考：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    //[a,b) -> [a,NULL)
    ListNode* reverse(ListNode* a, ListNode* b) {
        ListNode *cur = a, *pre = NULL, *nxt = a;
        while(cur!=b) {
            nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(!head) return head;
        ListNode *a=head, *b=head;
        for(int i=0; i<k; i++) {
            if(b==NULL) return head;
            b = b->next;
        }
        ListNode* newhead = reverse(a, b);
        a->next = reverseKGroup(b, k);
        return newhead;
    }
};