leetcode 25

K个一组反转链表，看到字节的面经说考了这题，复习一下。

之前写过，是借助数组做的，很容易想到的思路。

今天重写了一下，不用额外空间，用多个指针完成。

整个过程是一轮一轮进行的，每轮反转长为k的子链表，直到最后长度不足k时停止。在每一轮中，定义几个变量，oldHead表示该轮长为k的子链表的原头节点，newHead表示该子链表反转后的新头节点(就是反转前子链表的最后一个节点)，nextNode表示下一轮的头节点(newHead.next，需要在反转之前拿到)，lastTail表示上一轮反转过后子链表的最后节点(就是上一轮的oldHead)。每一轮先保存原头节点oldHead，然后把子链表反转了，得到newHead，用一个计数器表示目前是第几轮，是第一轮的话，该newHead就是最后的答案，用一个变量保存；否则让lastTail.next = newHead，每轮最后更新计数器（表示第几轮），更新lastTail = oldHead（这个一定要放在倒数第二步！不然会产生循环链表!），最后更新oldHead=nextNode（下一轮开始的头节点）。

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode oldHead = head;
        boolean ok = true;
        int cnt = 0;
        ListNode ans = null;
        ListNode lastTail = null;
        while(head != null && ok){
            //System.out.println(oldHead.val);
            ListNode nextNode = oldHead;
            for(int i = 0; i < k; i++){
                if(nextNode == null){
                    ok = false;
                    break;
                }
                nextNode = nextNode.next;
            }
            if(!ok){
                break;
            }

            ListNode newHead = reverse(oldHead, k);
            //System.out.println("lastTail="+(lastTail==null?"null":lastTail.val)+ " oldHead="+oldHead.val+" newHead="+newHead.val);
            oldHead.next = nextNode;
            if(cnt == 0){
                ans = newHead;
            } else{
                lastTail.next = newHead;
            }
            cnt++;
            lastTail = oldHead;
            oldHead = nextNode;

        }
        return ans;
    }

    private ListNode reverse(ListNode head, int k){
        ListNode prev = null;
        ListNode cur = head;
        int length = 0;
        while(cur != null){
            length++;
            cur = cur.next;
        }
        //System.out.println(length);
        //剩下的长度不足k,不反转，返回原来的头节点
        if(length < k){
            return head;
        }

        cur = head;
        for(int i = 0; i < k; i++){
            ListNode nextNode = cur.next;
            cur.next = prev;
            prev = cur;
            cur = nextNode;

        }
        return prev;
    }
}

最后放一下之前用的额外数组的方法把。总之链表的题，如果是笔试，只想通过的话，优先用简单的借助额外数组的方法，不超时能过就行，但是面试的话还是尽量想出只用指针的方法。

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        List<Integer> nums=new ArrayList<>();
        while(head!=null){
            nums.add(head.val);
            head=head.next;
        }
        for(int i=0;i<nums.size();i+=k){
            if(i+k<=nums.size()){
                swap(nums,i,i+k-1);
            }
        }
        ListNode dummy=new ListNode();
        ListNode current=dummy;
        for(int i=0;i<nums.size();i++){
            current.next=new ListNode(nums.get(i));
            current=current.next;
        }
        return dummy.next;
    }
    
    private void swap(List<Integer> num,int left,int right){
        int temp=0;
        while(left<right){
            temp=num.get(left);
            num.set(left,num.get(right));
            num.set(right,temp);
            left++;
            right--;
        }
    }
}