刷题——将单链表的每K个节点之间逆序

给定一个单链表的头结点head，实现一个调整单链表的函数，使得每K个节点之间逆序，如果最后不够K个节点一组，则不调整最后几个节点

解1：使用栈辅助，先把所有节点进栈，再出栈实现反向

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */

// 解法1： 使用栈辅助
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(k<2)
            return head;
        Stack<ListNode> stack = new Stack<ListNode>();
        ListNode cur = head;
        ListNode newhead = null;
        int cnt = 0;
        
        while(cur != null){
            stack.push(cur);
            cnt = (cnt+1)%k;
            cur = cur.next;
        }
        
        while(cnt-- != 0){
            stack.peek().next = newhead;
            newhead = stack.pop();
        }
        
        while(!stack.isEmpty()){
            cur=stack.pop();
            ListNode curhead = cur;
            cnt = k-1;
            while(cnt != 0){
                cur.next = stack.pop();
                cur = cur.next;
                cnt --;
            }
            cur.next = newhead;
            newhead = curhead;
        }
        return newhead;
    }
}

解2：不需要栈结构，在原链表中直接调整，难点在于要注意记录每组的head,tail，并将上一组的tail的next指针链接到本组的head，而且第一组要单独处理

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */

// 解法2： 不使用辅助栈，在原栈上直接以K个分组，进行逆置
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(k<2 || head==null)
            return head;
        
        ListNode curhead = head;
        ListNode cur = head;
        ListNode nexthead = null;
        ListNode lasttail = null;
        ListNode newhead = null;
        
        int cnt = 0;
        boolean fstgroup = true;
        while(curhead != null){
            // determining group head and tail
            cnt = 1;
            cur = curhead;
            while(cur!=null && cnt != k){
                cur = cur.next;
                cnt ++;
            }
            
            ListNode curtail = cur;
            nexthead = (cur!=null && cur.next!=null) ? cur.next : null;
            
            if( cur != null){
                if(fstgroup)
                    newhead = cur;
            }else{
                if(fstgroup)
                    return head;
                else{
                    lasttail.next = curhead;
                    return newhead;
                }
            }
            
            // reverse current group
            ListNode pre = null;
            ListNode next = null;
            cur = curhead;
            while(cur != nexthead){
                next = cur.next;
                cur.next = pre;
                pre = cur;
                cur = next;
            }
            
            if(fstgroup)
                lasttail = head;
            else{
                lasttail.next = curtail;
                lasttail = curhead;
            }
            
            curhead = nexthead;
            fstgroup = false;
            
        }
        
        return newhead;
    }
}