k 节点链表翻转

翻转

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例：

给你这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明：

你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

来源：力扣LeetCode
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

tip:
1. 递归
2. 关键是要存储每次的head， 下一次的head， 还要将两次翻转链接，所以还需要每次的尾节点。
head -> $\cdots$ -> tail -> nextHead

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        
        if (head == NULL) {
            return NULL;
        }

        return reverseKNode(head, k);
    }

    ListNode *getLastNode(ListNode *head, int k) {
        ListNode *tail = head;
        while(--k && tail != NULL) {
            tail = tail->next;
        }
        return tail;
    }

    ListNode *reverseKNode(ListNode *head, int k) {
        ListNode *result = getLastNode(head, k);
        if (result == NULL) { /* 不够k个不翻转，直接返回 */
            return head;
        }

        ListNode *nextHead = result->next;  /* 保持下一次待翻转的链表的头 */
        ListNode *temp = result;
        int tempK = k;
        while(--tempK) {
            temp->next = getLastNode(head, tempK);
            temp = temp->next;
        }
        temp->next = nextHead;
        temp->next = reverseKNode(nextHead, k);  /* 递归：下一轮翻转 */

        return result;
    }
};

旋转

给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

示例 1:

输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL
示例 2:

输入: 0->1->2->NULL, k = 4
输出: 2->0->1->NULL
解释:
向右旋转 1 步: 2->0->1->NULL
向右旋转 2 步: 1->2->0->NULL
向右旋转 3 步: 0->1->2->NULL
向右旋转 4 步: 2->0->1->NULL

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/rotate-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

1. 统计长度和找到尾节点
2. 左旋变右旋
3. 找到右旋之后的首节点
4. 将原来的首节点链接在位节点后
5. 新的尾节点的next赋值NULL

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

#define __DEBUG__ 0

class Solution
{
  public:
    ListNode *rotateRight(ListNode *head, int k)
    {
        if (head == NULL) {
            return NULL;
        }

        ListNode *tail = NULL;
        int cnt = getTotalLen(head, &tail);
        int step = cnt - k % cnt; /* 右旋变左旋 */
        if (step == cnt) {
            return head;
        }

        ListNode *temp = head;
        ListNode *newHead;
        ListNode *newTail;
        while (--step >= 0) {
            newTail = temp;
            temp = temp->next;    /* 保证到不了链表的尾节点，即temp 不为空 */
        }

        newHead = temp;           /* 将前面的点左旋到尾节点后面 */
        tail->next = head;
        newTail->next = NULL;
        return newHead;
    }

    int getTotalLen(ListNode *head, ListNode **tail)
    {
        int cnt = 1;
        while (head->next != NULL) {
            cnt++;
            head = head->next;
        }
        *tail = head;
        return cnt;
    }
};