PAT1074：Reversing Linked List Java语言实现

一、题目为：

Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 
1→2→3→4→5→6, if K = 3, then you must output 3→2→1→6→5→4; if K = 4, you must output 4→3→2→1→5→6.
Input Specification:
Each input file contains one test case. For each case, the first line contains the address of the first node, a positive N(<= 10^5​​) which is the total number of nodes, and a positive K(<= N) which is the length of the sublist to be reversed. The address of a node is a 5-digit
 nonnegative integer, and NULL is represented by -1.
Then N lines follow, each describes a node in the format:
Address Data Next 
where Address is the position of the node, Data is an integer, and Nextis the position of the next node.
Output Specification:
For each case, output the resulting ordered linked list. Each node occupies a line, and is printed in the same format as in the input.
Sample Input:
00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218
Sample Output:
00000 4 33218
33218 3 12309
12309 2 00100
00100 1 99999
99999 5 68237
68237 6 -1

二、题目分析
   将链表存入数组中，以输入案例来说，第一行的第一个数为链表头结点所在的位置，第二个数字表示要存入数组中的节点个数，请注意其中可以有多余节点，举例说明：可以看出来11111位置的节点，就是多余节点，不与链表相连。
00100 7 4
00000 4 99999
00100 1 12309
68237 6 -1
11111  8  44444
33218 3 00000
99999 5 68237
12309 2 33218
    其它的行，第一个数字表示存入数组的位置，第二个数字表示存入数组的数值，第三个数字表示链表的下一个节点的位置。第二行：00100 表示第一个节点的位置，即节点： 00100 1 12309 然后根据12309找到第二个节点：12309 2 33218，继续找，直到找到最后一个节点 68237 6 -1。
（以输入案例说明）

 
 

  
  
数组下标
00000
...
00100
…
12309
…
33218
…
68237
…
99999
节点值
4
…
1
…
2
…
3
…
6
...
5
节点的下一个指针
99999
…
12309
…
33218
...
00000
...
-1
...
68237
 
 


    其中，N表示要存入数组中的节点个数，与有效节点个数是有区别的，所以在程序中需要获取数组中存入的有效节点个数；K表示将链表内的每K个节点进行逆转再相连，

如：1->2->3->4->5->6->7->8，以K=4进行逆转之后，就会变成4->3->2->1->8->7->6->5；

又比如：1->2->3->4->5->6，以K=4进行逆转之后，就会变成4->3->2->1->5->6.

 
 

  
  

 
 
三、程序框架

（1）读取数组，将数据存入数组中，注意数组的容量为10^5；

（2）获取数组中属于链表的有效节点；

（3）当K=1时不需要进行逆转，当K>1时进行逆转；

（4）打印逆转后的链表，输出格式如输出案例所示，因为要显示“00000”，所以需要将整数型数据转化为字符型；最后一行的最后可以有回车符，但是不能有多余的空格；

package cn.eee.www;
import java.util.Scanner;

class ArrayNode {  
    int data;  
    int next;  
  
    public ArrayNode() {  
    }  
}  
  
public class Test12 {  
    public static void main(String[] args) {  
        // 读取数据存入数组  
        ArrayNode[] array = new ArrayNode[100000];  
        Scanner scan = new Scanner(System.in);  
        int head = scan.nextInt();  
        int N = scan.nextInt();  
        int K = scan.nextInt();  
        int current = 0;  
        int a = head;  
        for (int i = 0; i < N; i++) {  
            current = scan.nextInt();  
            array[current] = new ArrayNode();  
            array[current].data = scan.nextInt();  
            array[current].next = scan.nextInt();  
        }  
        // 返回数组中有效的节点个数，为了防止数组中有多余的节点  
        N = number(head, array, N);  
        // 逆转单向链表  
        if (K > 1) {  
            a = reverse(head, array, N, K);  
        }  
        // 打印逆转后的链表  
        display(a, array, N);  
    }  
  
    /* 
     * 改变输出数字格式 在不够五位数的前面补0 
     */  
    public static String change(int val) {  
        if (val == -1) {  
            return val + "";  
        }  
        String s = "00000";  
        String first = val + "";  
        int length = first.length();  
        s = s.substring(length) + first;  
        return s;  
    }  
  
    /* 
     * 打印数组中的静态链表 
     */  
    public static int display(int head, ArrayNode[] arr, int N) {  
        int num = 0;  
        while (head != -1) {  
            String head1 = change(head);  
            String next1 = change(arr[head].next);  
            System.out.println(head1 + " " + arr[head].data + " " + next1);  
            head = arr[head].next;  
            num++;  
        }  
        return num;  
    }  
  
    // 返回数组中有效的节点个数  
    public static int number(int head, ArrayNode[] arr, int N) {  
        int num = 0;  
        while (head != -1) {  
            head = arr[head].next;  
            num++;  
        }  
        return num;  
    }  
  
    //以K为分界线对单向链表进行逆转  
    public static int reverse(int head, ArrayNode[] arr, int N, int K) {  
        int num = 1;  
        int reverse = 1;  
        int remain = head;  
        int old_head = arr[head].next;  
        int new_head = head;  
        int temp;  
        int remain2 = head;  
        while (reverse <= N / K) {  
            while (num < K) {  
                temp = arr[old_head].next;  
                int a = arr[old_head].data;  
                // 注意这里需要给数组该位置创建一个结点，不能直接用“arr[old_head].next= new_head”会影响old_head的值；  
                arr[old_head] = new ArrayNode();  
                arr[old_head].data = a;  
                arr[old_head].next = new_head;// 将链表方向逆转  
                new_head = old_head;  
                old_head = temp;  
                num++;  
            }  
            if (reverse == 1) {// 第一次逆转时，找到头节点，并将逆转之后的节点与还没逆转的节点相连  
                head = new_head;  
                arr[remain].next = old_head;  
            } else {// 第i(i>1)次的逆转，都直接把逆转之后的节点与第i+1次逆转之后的节点连接起来  
                arr[remain].next = new_head;  
                remain = remain2;  
            }  
            if (old_head == -1) {// 当链表逆转结束时，将尾节点的下一个指向-1  
                arr[remain2].next = -1;  
            } else {// 如果一轮逆转之后链表还没结束，则还需要再进行一轮逆转，所以把所有的节点都往后移一位  
                new_head = old_head;  
                old_head = arr[old_head].next;  
                remain2 = new_head;  
            }  
            num = 1;  
            reverse++;  
        }  
        return head;  
    }  
  
}