pat 1025 反转链表 Java解法22分

                                                                          1025 反转链表 (25 分)

给定一个常数 K 以及一个单链表 L，请编写程序将 L 中每 K 个结点反转。例如：给定 L 为 1→2→3→4→5→6，K 为 3，则输出应该为 3→2→1→6→5→4；如果 K 为 4，则输出应该为 4→3→2→1→5→6，即最后不到 K 个元素不反转。

输入格式：

每个输入包含 1 个测试用例。每个测试用例第 1 行给出第 1 个结点的地址、结点总个数正整数 N (≤10​5​​)、以及正整数 K (≤N)，即要求反转的子链结点的个数。结点的地址是 5 位非负整数，NULL 地址用 −1 表示。

接下来有 N 行，每行格式为：

Address Data Next

其中 Address 是结点地址，Data 是该结点保存的整数数据，Next 是下一结点的地址。

输出格式：

对每个测试用例，顺序输出反转后的链表，其上每个结点占一行，格式与输入相同。

输入样例：

00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

解题思路：

此题题目说明是链表 实际考察对 字符串 数组和集合的转化反转，排序，增删查的处理。还有面向对象和重写方法的应用。

参照大神https://blog.csdn.net/huanglei305/article/details/105138615 的解法，还是会有一个测试点超时

详细解释在代码注释中；

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class Main {
    public static class Node{    //创建结点类
        public int adress ;
        public int value ;
        public int next ;
        public Node(int adress,int value,int next){
            this.adress = adress;
            this.value = value;
            this.next = next;
        }

        @Override    //重写输出字符串方法，对最后一个结点单独考虑
        public String toString(){
            if(this.next != -1){
                return String.format("%05d",adress)+" "+value+" "+String.format("%05d",next);
            }else {
                return String.format("%05d",adress)+" "+value+" "+String.format("%02d",next);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String[] buf = bf.readLine().split(" "); 
        int head = Integer.parseInt(buf[0]);
        int n = Integer.parseInt(buf[1]);
        int f = Integer.parseInt(buf[2]);
        Node[] nodes = new Node[100000];
        for (int i = 0; i < n; i++) {
            buf = bf.readLine().split(" ");
            int adress = Integer.parseInt(buf[0]);
            int value = Integer.parseInt(buf[1]);
            int next = Integer.parseInt(buf[2]);
            nodes[adress] = new Node(adress,value,next);
        }
        EachAndReverse(nodes,head,f);
    }

    public static void EachAndReverse(Node[] nodes, int start, int reverse){
        int index = start;
        ArrayList<Node> list1 = new ArrayList<>();
        ArrayList<Node> list2 = new ArrayList<>();
        list1.add(nodes[index]);    //单独写一次是因为考虑到只有一个结点的情况   
        while ((index = nodes[index].next)!=-1){   
            list1.add(nodes[index]);
        }
        int length = list1.size();
        int ReverseTime = length/reverse;
        for (int i = 0; i < ReverseTime; i++) {
            for (int j = reverse-1; j > -1 ; j--) {
                list2.add(list1.remove(j));   //对列表一f个数做相应反转，并在1中删除反转过 的数
            }
        }
        for (Node node:list1){
            list2.add(node);    //把1中没有做反转的剩下的数挪到2中
        }

        int AddressTemp = -1;
        for (int i = length-1; i >-1 ; i--) {   //更新列表的next结点
           list2.get(i).next = AddressTemp;
           AddressTemp = list2.get(i).adress;
        }

        for (Node node: list2) {    //因为做过重写方法 可直接输出
            System.out.println(node);
        }
    }
}