PTA-02-线性结构3 Reversing Linked List

02-线性结构3 Reversing Linked List（25 分）

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$ ($\le 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 Next is 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

import java.util.Scanner;
//创建一个结点
class node{
	int data;//暂时忽略00xxx的状况，实在不会
	int next; 
}

class Main{
	public static void main(String []args){
		Scanner scan = new Scanner(System.in);
		int head = scan.nextInt();
		int N = scan.nextInt();
		int K = scan.nextInt();
		int head1 = head;
		node []array = new node[100000]; 
		for(int i=0;i<N;i++){//将所有的数据存储在数组中
			int node = scan.nextInt();
			array[node] = new node();
			array[node].data = scan.nextInt();
			array[node].next = scan.nextInt();
		}
		N = number(array,head);
		if(K>1){
			head1 = reverse(array,N,K,head);
		}
		print(head1,array);
		
		
	}
	//返回与链表相连的结点的个数，因为有些结点可能不与链表相连，不需要逆转
	public static int number(node []array,int head){
		int number = 1;
		while(head!=-1){
			head = array[head].next;
			number++;
		}
		return number;
	}
	//返回需要逆转的头结点，同时逆转链表
	public static int reverse(node []array,int N,int K,int head){
		int remain = head;
		int remain2 = head;
		int new_head = head;
		int old_head = array[new_head].next;
		int temp;
		int number = 1;
		int reverse = 1;
		while(reverse<=N/K){//判断逆转的次数
			while(number<K){
				temp = array[old_head].next;
				array[old_head].next = new_head;
				new_head = old_head;
				old_head = temp;
				number++;
			}
			if(reverse==1){
				array[remain].next = old_head;
				head = new_head;
			}
			else{
				array[remain].next = new_head;
				remain = remain2;
			}
			if(old_head==-1){
				array[remain2].next = -1;
			}
			else{
				new_head = old_head;
				old_head = array[old_head].next;
				remain2 = new_head;
			}
			number = 1;
			reverse++;
		}
		return head;
	}
        //因为开头是五位数，所以前面不足的地方得补0
	public static String transform(int k){
		String s = "00000";
		String first =k+"";
		int length = first.length();
		s = s.substring(length)+first;
		if(k ==-1){
			return k+"";
		}
		return s;
	}
	//打印链表
	public static void print(int head,node []array){
		while(head!=-1){
			String  head1 = transform(head);
			String next1 = transform(array[head].next);
			System.out.println(head1+" "+array[head].data+" "+next1);
			head = array[head].next;
		}
	}
}

这个是我参考别人写的代码然后稍微做了一下小修改，然后加入了自己的一点补充，在树的那个章节中陈越老师也做了伪代码的 实现，要是没有看到那章的可以去看看，便于更好理解这个题目中最核心的部分，运行情况如下图，还是有一些缺陷，具体怎么改我也不知道，先留个坑吧，或许将来有时间我会再来看看