链表中每k个一组反转

package linked;

import java.util.ArrayList;
import java.util.Scanner;

public class ReverseKGroup {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		String str = input.nextLine();
		int k = (int)str.charAt(str.length() - 1) - 48;
		String[] array = str.substring(0 , str.length() - 2).replace('{', ' ').replace('}', ' ').trim().split(",");
		int[] data = new int[array.length];
		for(int i = 0;i < array.length;i++) {
			data[i] = Integer.parseInt(array[i]);
		}
		LinkedNode head = createLinked(data);
		reverseKGroup (head, k);
	}
	
	//创建链表
	public static LinkedNode createLinked(int[] array) {
		LinkedNode head = null;
		LinkedNode next = null;
		for(int i = 0;i < array.length;i++) {
			LinkedNode node = new LinkedNode(array[i],null);
			if(i == 0) {
				head = node;
				next = head;
			}else {
				next.next = node;
				next = node;
			}
		}
		return head;
	}
	
	
	/**
	 * 基本思路：
	 * 值得注意的是：反转链表反转的是链表中的元素，没有必要改变链表的结构
	 * 我们的基本思想是使用一个ArrayList（不使用数组是因为链表的元素个数我们无法判断）
	 * 先把链表中的元素给取出来，然后按每k个分组反向赋值给链表中的元素，不足k个的直接不处理
	 * */
	public static LinkedNode reverseKGroup (LinkedNode head, int k) {
		//判断如果链表为空就没有必要处理直接返回
		if(head == null || k == 1 ){
            return head;
        }
        ArrayList<Integer> list = new ArrayList<Integer>();
        LinkedNode node = head;
        while(node != null) {
        	list.add(node.val);
        	node = node.next;
        }
        
        //判断如果不足K个也没有必要处理，不直接在方法的前面返回的原因是这个时候才知道链表的元素个数
        if(list.size() < k){
            return head;
        }
        
        node = head;
        int index = k - 1;
        while(true){
            node.val = list.get(index);
            node = node.next;
            if(index % k == 0){
                index = index + 2 * k - 1;
            }else{
                index--;
            }
            if(index == list.size() - list.size() % k - k){
                node.val = list.get(index);
                break;
            }
        }
        return head;	
     }
}