Leetcode 25. Reverse Nodes in k-Group

方法1： recursion。真的是一下就想到recursion，但是recursion注定空间复杂度不是1。但是recursion是一个非常好的开始，可以为方法2做铺垫。我这边是用了一个arraylist存放reverse后的每k个node。然后最后把arraylist中的node全部连起来就好了。时间复杂n的平方，空间复杂n。我建议去看一下lc的官方解答1，它上面的recursion更好，时间复杂是n，而且没用多余的数据结构存储nodes。这边展示一下我自己的代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode curr1 = head;
        List<ListNode> myList = new ArrayList<>();
        int count = 1;
        while(curr1 != null){
            ListNode nextNode = curr1.next;
            if(count == k){
                curr1.next = null;
                myList.add(reverse(head));
                count = 0;
                head = nextNode;
            }
            curr1 = nextNode;
            if(curr1 == null && count < k){
                myList.add(head);
            }
            count++; 
        }
        
        ListNode res = myList.get(0);
        for(int i = 0; i < myList.size() - 1; ++i){
            ListNode first = myList.get(i);
            ListNode second = myList.get(i + 1);
            ListNode curr = first;
            while(curr.next != null){
                curr = curr.next;
            }
            curr.next = second;
        }
        return res;
    }
    
    private ListNode reverse(ListNode head) {
        ListNode prev = null;
        while(head != null){
            ListNode tmp = head.next;
            head.next = prev;
            prev = head;
            head = tmp;
        }
        return prev;
    }
}

方法2: 这个方法保证了空间复杂是1，用的是iterate的思想。今天效率有点低，已经挺晚的了，我不想看了，下次复盘的时候记得一定要去看一遍。我发现了大厂喜欢考的题目都是能分好几次去优化的，像我现在只是做了个最基础的，一点优化都没有，这是不行的。下次复盘，这个lc方法2一定要去看。

总结：

• 无