PAT 02-线性结构3 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”，所以需要将整数型数据转化为字符型；最后一行的最后可以有回车符，但是不能有多余的空格；

四、程序源码：

import java.util.Scanner;class ArrayNode {int data;int next;public ArrayNode() {}}public class Test {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) {// 当链表逆转结束时，将尾节点的下一个指向-1arr[remain2].next = -1;} else {// 如果一轮逆转之后链表还没结束，则还需要再进行一轮逆转，所以把所有的节点都往后移一位new_head = old_head;old_head = arr[old_head].next;remain2 = new_head;}num = 1;reverse++;}return head;}}

五、测试点分析

测试点1，如案例所示；

测试点2，题目分析中也有说明；

测试点3，当K=N时正好链表上所有的节点都进行一次反转；

测试点4，当K=1时不用反转；

测试点5，不用解释吧；

测试点6，即当N取到10^5时，要反转X=N/K次，还剩下K-1个节点不反转；

测试点7，题目分析中也有说明，需要获取数组中存在的有效节点个数。

注：此处我的测试点6为运行超时，是因为该系统用JAVA编程耗时太多，有多个题目都是这样，如果有解决办法的朋友，可以留言提醒，谢谢！

额外附送：

1、陈越老师对这题的讲解视频链接：

http://www.icourse163.org/learn/ZJU-93001?tid=1001757011#/learn/content?type=detail&id=1002249375

2、陈越老师对单向链表逆转模块的图解：

3、单向链表逆转的伪代码：

LinkList Reverse (LinkList head, int K)    //单链表逆转K个结点 且仅一次  2 { 3     int cnt = 1;        //用于计数已逆转的结点数  4     LinkList new_ = head->next; 5     LinkList old = new_->next; 6     LinkList tmp;         7     while(cnt < K) {      8         tmp = old->next;    //用于old结点逆转后 记录未逆转链表的头结点  9         old->next = new_;    //逆转 10         new_ = old;            //向后移位 11         old = tmp;            //向后移位 12         cnt++;                //逆转节点+1 13     }14     head->next->next = old;15     return new_;        //新的头结点 16 }