zoukankan      html  css  js  c++  java
  • 【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;
    }
  • 相关阅读:
    【C++ OpenGL ES 2.0编程笔记】8: 使用VBO和IBO绘制立方体 【转】
    顶点缓存对象(VBO)【转】
    CompileGLShader
    VR虚拟现实的工作原理,你知道多少?【转】
    VR/AR工作原理、目前存在的技术问题
    Got fatal error 1236 from master when reading data from binary log: 'Could not find first log file name in binary log index file'
    nginx配置用户认证
    恢复阿里云RDS云数据库MySQL的备份文件到自建数据库
    阿里云rds linux平台使用wget 工具下载备份与日志文件
    screen 命令使用及示例
  • 原文地址:https://www.cnblogs.com/dplearning/p/4310794.html
Copyright © 2011-2022 走看看