浙大PAT甲级（1074）java题解

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

/**
 * @program: 浙大PAT甲级1074 java题解（满分25 此题22分 一条测试用例超时）
 * @description:
 * @author: 国宇航
 * @create: 2019-12-31 15:13
 **/
public class onezerosevenfour {
    static class LNode{
        int data;
        int next;
        int address;
        LNode child;
        public LNode(int address,int data,int next){
            this.address = address;
            this.data =data;
            this.next = next;
        }
    }
    //不带头结点反转函数
    public  static LNode reverse(LNode head){
        if(head==null){
            return null;
        }
        if(head.child==null){
            return head;
        }
        LNode pre= null;
        LNode next = null;

        while (head!=null){
            next = head.child;
            head.child = pre;
            pre = head;
            head = next;
        }
        return pre;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String b[] = bufferedReader.readLine().split(" ");
        int start=Integer.parseInt(b[0]);
        int sum =Integer.parseInt(b[1]);
        int M = Integer.parseInt(b[2]);
//        System.out.println(sum);
        ArrayList<LNode> arrayList = new ArrayList<LNode>();
//        int start = 00000;
        //00000 3 3
//        LNode node1 = new LNode(00000,4,99999);
//        LNode node2 = new LNode(99999,5,68237);
//        LNode node3 = new LNode(68237,6,-1);
        for(int i = 0 ;i<sum;i++){
            String a[] = bufferedReader.readLine().split(" ");
            LNode node = new LNode(Integer.parseInt(a[0]),Integer.parseInt(a[1]),Integer.parseInt(a[2]));
            arrayList.add(node);
        }
//输入流关闭
        bufferedReader.close();

        LNode parent=null;
        LNode first = null;
        //记录给出序列的有用的节点数量（题中会给出脏结点）
        int count=0;
        for (LNode node : arrayList) {
            if (node.address == start) {
                parent = node;
                first = parent;
                count++;
            }
        }
        while (parent.next!=-1) {
            for (LNode node : arrayList) {
                if (parent != null && parent.next == node.address) {
                    parent.child = node;
                    parent = node;
                    count++;
                }
            }
        }
//        for(LNode node = first;node!=null;node=node.child){
//            System.out.println(node.data);
//        }
//        System.out.println("===========");
//        System.out.println(count/M);
        LNode rHead = null;
        LNode reverse1 = null;
        ArrayList<LNode> arrayList1 = new ArrayList<LNode>();
        //每次反转之后的链表都加入到arrayList1当中
        //反转所有
        if(count/M<1){
            LNode reverse = reverse(first);
            for (LNode node = reverse; node != null; node = node.child) {
                if (node.child != null) {
                    node.next = node.child.address;
                }
                if (node.child == null) {
                    node.next = -1;
                }
                String address = String.format("%05d",node.address);
                String next = String.format("%05d",node.next);
                if (next.equalsIgnoreCase("-0001") ) {
                    next = "-1";
                }
                System.out.println(address + " " + node.data + " " + next);
            }
            //否则分段反转
        }else {
            for (int i=0;i<count/M;i++) {
                LNode p = first;
                LNode k = p.child;
                int count2 = 1;
                while (count2 < M) {
                    count2++;
                    p = p.child;
                }
                rHead = p.child;
                p.child = null;
                //反转一次入栈一次
                reverse1 = reverse(first);
                arrayList1.add(reverse1);
                first = rHead;
            }
            //将剩余未翻转链表头节点放入arraylist
            arrayList1.add(first);
            for(int i = 0;i<count/M;i++){
                LNode node1 = arrayList1.get(i);
                LNode  node2 = node1;
                while (node2.child!=null){
                    node2 = node2.child;
                }
                node2.child = arrayList1.get(i+1);
            }
            for (LNode node = arrayList1.get(0); node != null; node = node.child) {
                    if (node.child != null) {
                        node.next = node.child.address;
                    }
                    if (node.child == null) {
                        node.next = -1;
                    }
                    String address = String.format("%05d",node.address);
                    String next = String.format("%05d",node.next);
                    if (next.equalsIgnoreCase("-0001") ) {
                        next = "-1";
                    }
                    System.out.println(address + " " + node.data + " " + next);
                }
        }

    }
}

不知道超时的测试用例是哪个 用java实在是太慢了 而且不适合考试
用C++ vector和取地址等操作可以一步到位 代码行数40以内