PAT 7-2 Reversing Linked List

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 (≤105) 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 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

 这个题有点烦, 本来都已经反转完成了, 但是它的输入样例是类似内存中存储的结构, 还要转换一下, 又花了许多时间.

我的代码设计了3个链表, 第一个链表存储反转后的链表, 第二个链表存储暂时反转的结点, 要记录结点的个数, 结点个数达到K个, 就把第二个链表的所有结点接到第一个链表上.第三个链表存储输入的所有数据, 向第二个链表反转, 如果最终第二个链表的结点个数不到K个, 再反转回第三个链表, 第三个链表正序接到第一个链表的尾巴上.

#include <stdio.h>
#include <stdlib.h>

struct Node {
	int index;
	int data;
	int point;
	struct Node* next;
};
typedef struct Node* List;

void printList(List head);
void FreeList(List head);
List reverseK(List head, int K);

int main( void )
{
	int a[100000][2];
	int first, num, K;
	scanf("%d %d %d", &first, &num, &K);
	int index;
	for( int i=0; i<num; i++ ) {
		scanf("%d", &index);
		scanf("%d %d", &a[index][0], &a[index][1]);
	}
//	printf("%d", a[00000][0]);
	List head = (List)malloc(sizeof(struct Node));
	List rear = head;
	List tmp;
	while ( first != -1 ) {
		tmp = (List)malloc(sizeof(struct Node));
		tmp->index = first;
		tmp->data = a[first][0];
		tmp->point = a[first][1];
		first = tmp->point;
		rear->next = tmp;
		rear = rear->next;
	}
	rear->next = NULL;
	tmp = head;
	head = head->next;
	free(tmp);
	List p2 = reverseK(head, K);
	printList(p2);
	FreeList(p2);
	return 0;
}

void printList(List head)
{
	List tmp;
	while ( head->next ) {
		tmp = head;
		tmp->point = tmp->next->index;
		head = head->next;
		printf("%05d %d %05d\n", tmp->index, tmp->data, tmp->point);
	}
	printf("%05d %d -1", head->index, head->data, head->point);
	return;
}

void FreeList(List head)
{
	while ( head ) {
		List tmp = head;
		head = head->next;
		free(tmp);
	}
	return;
}

List reverseK(List head, int K)
{
	List p1 = (List)malloc(sizeof(struct Node));//逆转之后存储的堆栈 
	List p2 = (List)malloc(sizeof(struct Node));//暂时存储K个结点的堆栈 
	p2->next = NULL;
	List r1 = p1;//p1的尾结点,直接把p2的结点往上加 
	List r2 = p2;
	List newhead = (List)malloc(sizeof(struct Node));
	newhead->next = head;
	int cnt = 0;//计数器,按余数循环 
	List tmp;
	while ( newhead->next ) {
		tmp = newhead->next;
		newhead->next = tmp->next;
		tmp->next = p2->next;
		p2->next = tmp;
		if ( !tmp->next )//tmp->Next == 0
			r2 = tmp;
		if ( ++cnt % K == 0 ) {//cnt+=1,再对K求余 
			r1->next = p2->next;
			r1 = r2;
			r2 = p2;
			p2->next = NULL;
		}
	}
	while ( p2->next ) {//p2里面剩下的结点,要逆转回newhead再加到p1 
		tmp = p2->next;
		p2->next = tmp->next;
		tmp->next = newhead->next;
		newhead->next = tmp;
	}
	r1->next = newhead->next;
	tmp = p1;
	p1 = p1->next;
	free(newhead);
	free(p2);
	free(tmp);
	return p1;
}