【CodeTop刷题日记5】 K 个一组翻转链表

K 个一组翻转链表

关于链表的题还是挺有规律性可言的
只要搞清楚内部到底是怎么个变化法，就还是能写出来的
只不过就是简洁不简洁的问题

一、读题

其实只要找个实例自己连一连就知道咋弄的了，就像这：

二、数据结构

一开始的想法是：在反转链表的同时，还要考虑是否满足条件翻转（够k个）
所以就有了存储节点指针再判断的念头

就想着用一个k个容量的容器去存储，满了就反转
每次清空，不满且p指到空了就拉倒

三、细节

走一走就会发现，有几个关键的量是需要记下来的：

1. 要返回的函数头(newhead)
   如果不翻转就是head，如果翻转就是第一次翻转容器里最后一个元素
2. 每一段翻转后链表的尾巴 (pre)
   pre要去连接下一段反转的容器里最后一个元素 v[v.size()-1]
   

其实我也不太会写，我是按基本想法写一遍之后去调整细节的

/**
 * 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 {
private:
    vector<ListNode*> v;
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* pre = nullptr;
        ListNode* p = head;
        ListNode* newhead = head;
        while(p){  //总循环，遍历链表
            while(p && v.size() < k){  //塞满vector，准备翻转
                v.push_back(p);
                p = p->next;
            }
            //if(p) ListNode* tmp = p->next;
            if(v.size() == k){  //需要进行一次翻转
                if(!pre)newhead = v[v.size()-1];
                else pre->next = v[v.size()-1];
                for(int i=0;i<v.size();i++){
                    if(!i){
                        v[i]->next = nullptr;
                    }
                    else v[i]->next = v[i-1];
                }
                pre = v[0];
                v.clear();
            }else{  //最后一段不翻转
                if(pre){  //此时的v中一定有元素，因为如果无元素那就不会进内层循环
                    pre->next = v[0];
                }
            }
        }
        return newhead;
        
    }
};