1025 反转链表（JAVA）

给定一个常数 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 (≤105)、以及正整数 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

输出样例：

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

代码实现：

import java.io.*;
import java.util.ArrayList;

/**
 * @author yx
 * @date 2022-07-15 13:16
 */
public class Main {
    static PrintWriter out=new PrintWriter(System.out);
    static BufferedReader ins=new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in=new StreamTokenizer(ins);

    static class Node{
        int Address;
        int Data;
        int Next;
        Node(int Address,int Data,int Next){
            this.Address=Address;
            this.Data=Data;
            this.Next=Next;
        }
    }

    public static void main(String[] args) throws IOException {
        in.nextToken();
        int initAddress=(int) in.nval;
        in.nextToken();
        int N=(int) in.nval;//输入的数字组数
        in.nextToken();
        int K=(int) in.nval;//需要反转的节点个数
        ArrayList<Node> list=new ArrayList<>();//定义一个新链表
        Node[] nums=new Node[100000];
        for (int i = 0; i < N; i++) {
            in.nextToken();
            int address=(int) in.nval;
            in.nextToken();
            int data=(int) in.nval;
            in.nextToken();
            int next=(int) in.nval;
            nums[address]=new Node(address,data,next);
        }
        //生成一个原始链表
        while (initAddress!=-1){
            list.add(nums[initAddress]);
            initAddress=nums[initAddress].Next;
        }

        /*
        开始链表反转
         */
//        set() 方法用于替换动态数组中指定索引的元素。
//        语法
//        set() 方法的语法为：
//        arraylist.set(int index, E element)
//        注：arraylist 是 ArrayList 类的一个对象。
//        参数说明：
//        index – 索引位置
//        element – 将在 index 位置替换进去的新元素
//                返回值
//        返回之前在 index 位置的元素 。
//        原文链接：https://blog.csdn.net/weixin_32770687/article/details/114511359

        /*
        这个地方一定要注意不能用N代替list.size()，这个点很关键，因为N代表的是输入
        但实际上是输入进去的数据不一定都是有用的，当无效输入时是不会加入链表的
        （输⼊样例中有不在链表中的结点的情况）
        一开始下面全部用N，会导致最后一个测试点非零返回
        把N改成list.size()，最后一个测试点通过
         */
        for (int i = 0; i+K-1 < list.size(); i+=K) {
            int t=i+K-1;
            //双指针移动，往中间夹
            for (int j = i; j <t ; j++,t--) {
                Node temp=list.get(t);
                list.set(t,list.get(j));//把t位置的值用list.get(j)来替换
                list.set(j,temp);//把j位置的值用temp来替换
            }
        }
        /**
         * 这个地方有一个BUG可以钻，就是不需要重新改变Next的值，因为每一个节点的Next就是下一个节点的Addreaa
         * 所以Next=list.get(i+1).Address，即可，最后一个的Next默认就是-1
         */
        for (int i = 0; i < list.size()-1; i++) {
            out.printf("%05d %d %05d\n",list.get(i).Address,list.get(i).Data,list.get(i+1).Address);
        }
        out.printf("%05d %d -1\n",list.get(list.size()-1).Address,list.get(list.size()-1).Data);
        out.flush();
    }
}

Tips：

这个题目我也是用了IO输入输出，代码也是经过了几次的优化，但最终还是超时一个点，emm，没办法，只能说Java在PTA吃不开