【leetcode】Reverse Nodes in k-Group （hard）☆

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For example,
Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

 

思路：

我的想法是把每一组的翻转单独列出来，每次翻转时都顺次翻转跟着的元素，如果遇到数目不够的再把后面的翻转回去。

代码略长...

//start time = 10:36
//end time = 13:27
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
using namespace std;

 struct ListNode {
      int val;
      ListNode *next;
      ListNode(int x) : val(x), next(NULL) {}
  };

class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        ListNode * anshead = NULL; //答案头结点
        ListNode * anstail = NULL; //已经翻转过的链表的尾结点
        ListNode * parthead = NULL; //当前组翻转后的头结点
        ListNode * parttail = NULL; //当前组翻转后的尾结点
        ListNode * nxthead = NULL; //下一次翻转时的头结点

        int num = reverse(head, k, nxthead, parthead, parttail);
        //链表总长度不足k 把部分翻转的再还原回去
        if(num != 0)
        {
            head = parthead;
            reverse(head, num, nxthead, parthead, parttail);
            return parthead;
        }
        anshead = parthead; //确定答案头结点是第一次翻转后的头结点
        //只要后面还有非空指针 就接着翻转下一组k个元素
        while(nxthead != NULL)
        {
            anstail = parttail;
            head = nxthead;
            num = reverse(head, k, nxthead, parthead, parttail);
            if(num != 0) //该组不足k个元素 恢复后面的元素
            {
                head = parthead;
                reverse(head, num, nxthead, parthead, parttail);
                anstail->next = parthead;
                return anshead;
            }

            anstail->next = parthead; //把新翻转后的组加在答案的末尾
        }

        return anshead;
    }

    //翻转一组k个元素 
    //输入： head 当前需要翻转链表的头结点   k 需要翻转的个数
    //输出： nxthead 下一次翻转时的头结点  parthead 当前组翻转后的头结点 parttail 当前组翻转后的尾结点
    //返回 0表示完成翻转 返回非0表示不足k个

    int reverse(ListNode *head, int k, ListNode * &nxthead, ListNode * &parthead, ListNode *&parttail)
    {
        //头为空 直接返回
        if(head == NULL)
        {
            parthead = head;
            return 0;
        }
        
        parttail = head; //当前k个元素组的链尾
        parthead = head; //当前组的链头
        ListNode * cur = head->next; //当前待翻转的元素
        parttail->next = NULL;

        int n = k - 1;
        while(n--)
        {
            //不够k个 把已经翻转过的转回来
            if(cur == NULL)
            {
                return k - n + 1; //返回需要在尾部翻转回的链表长度
            }

            ListNode * nxt = cur->next;
            cur->next = parthead;
            parthead = cur;
            cur = nxt;
        }

        nxthead = cur;

        return 0;
    }
};

 

看了别人精简的代码，每次先循环判断当前组是否够k个元素，省去了判断是否需要重新翻转的麻烦

O(n) and O(1) of course it is.

Each time when starting, find the future new head (nh) and save the old head of the next to-be-reversed list. If existed, nh is k step far from oh. Then reverse the list from oh to nh and save its tail for combination.

Example:

1-2-3-4-5

iter1: oh = 1, nh = 2 2-1-3-4-5

iter2: oh = 3, nh = 4 2-1-4-3-5

iter3: oh = 5, nh = 0 2-1-4-3-5

 ListNode *reverseKGroup(ListNode *head, int k) {
    if(!head || !head->next || k==1) return head;
    int i=k;
    ListNode * p0 = head, * p1 = head->next, * p2 = 0, * t = 0, * ret = head, *oh, * nh;
    while(p1)
    {
        oh = nh = p0;
        i = k;
        while(--i && nh)
            nh = nh->next; //判断后面是否够k个元素
        if(!nh) break; //不够直接跳出
        i = k;
        while(--i) //翻转后面的k个元素
        {
            p2 = p1->next;
            p1->next = p0;
            p0 = p1;  //p0是一组的头结点
            p1 = p2;
        }
        if(t) //已经翻转后的尾部加上新的元素
            t->next = p0;
        else
            ret = p0; //确定头结点
        p0 = oh;
        t = p0; //最初当前组的头结点oh 是现在的尾部

        p0 = p0->next = p1; //新的待判断的头结点
        if(p1)
            p1 = p1->next; //新的头结点的下一个结点
    }
    return ret;
}

 

转载于:https://www.cnblogs.com/dplearning/p/4310794.html