1025. 反转链表 (25)--PAT乙级

1025. 反转链表 (25)

时间限制

300 ms

内存限制

65536 kB

代码长度限制

8000 B

判题程序

Standard

作者

CHEN, Yue

给定一个常数K以及一个单链表L，请编写程序将L中每K个结点反转。例如：给定L为1→2→3→4→5→6，K为3，则输出应该为3→2→1→6→5→4；如果K为4，则输出应该为4→3→2→1→5→6，即最后不到K个元素不反转。

输入格式：

每个输入包含1个测试用例。每个测试用例第1行给出第1个结点的地址、结点总个数正整数N(<= 10⁵)、以及正整数K(<=N)，即要求反转的子链结点的个数。结点的地址是5位非负整数，NULL地址用-1表示。

接下来有N行，每行格式为：

Address Data Next

其中Address是结点地址，Data是该结点保存的整数数据，Next是下一结点的地址。

输出格式：

对每个测试用例，顺序输出反转后的链表，其上每个结点占一行，格式与输入相同。

输入样例：

00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

输出样例：

00000 4 33218
33218 3 12309
12309 2 00100
00100 1 99999
99999 5 68237
68237 6 -1

分析：由于链表随机访问操作较麻烦，这里使用的是数组进行反转操作，主要是根据题意找到对应的下标输出即可

，注意每一组反转的最后一个的下一结点地址。（下面自已写的程序一直有一个测试点过不了，若发现请指正！！）

代码：

#include<stdio.h>
#include<malloc.h>
using namespace std;
#define MAX 100000 + 5
struct node 
{
	int data;
	int next;
}Node[MAX];
struct node1
{
	int data;
	int address;
}Node1[MAX];
int main()
{
	//freopen("E:\\a.txt", "r", stdin);
	//freopen("E:\\b.txt", "w", stdout);
	int FirstAds, N, K, Num, Ads, i, j, t;
	scanf("%d%d%d", &FirstAds, &N, &K);
	for(i = 0; i < N; ++i)//输入 
	{
		scanf("%d", &Num);
		scanf("%d%d", &Node[Num].data, &Node[Num].next);
	}
	Ads = FirstAds;
	i = 0;
	while(Node[Ads].next != -1)//按地址连成链表，顺序存储 
	{
		Node1[i].data = Node[Ads].data;
		Node1[i].address = Ads;
		Ads = Node[Ads].next;
		++i;
	}
	
	Node1[i].data = Node[Ads].data;
	Node1[i].address = Ads;
	Node1[i+1].address = -1;

	j = N / K;
	t = 0;
    for(i = 1; i <= j; ++i)
    {
    	for(t = 1; t < K; ++t)//反序转出即达到反转的效果	
    	{
    		printf("%05d %d %05d\n", Node1[K * i - t].address, Node1[K * i - t].data, Node1[K * i - t - 1].address);
  	
		}
		//输出每组反转序列的最后一个 
		if(N != i * K && i != j)//后面还有需要反转的链表 
		printf("%05d %d %05d\n", Node1[K * i - t].address, Node1[K * i -t].data, Node1[K*(i+1) - 1].address);
		else if(N != i * K && i == j)//后面已无需要反转的序列 
		printf("%05d %d %05d\n", Node1[K * i -t].address, Node1[K * i - t].data, Node1[K * i].address);
		else //序列 全需反转 
		printf("%05d %d %d\n", Node1[K * i - t].address, Node1[K * i - t].data, Node1[K * i].address);
	}
	if(N % K != 0)//按序输出无需反转的序列 
	{
		for(i = j * K; i < N - 1; ++i)
		{
			printf("%05d %d %05d\n", Node1[i].address, Node1[i].data, Node1[i+1].address);
		}
		printf("%05d %d %d\n", Node1[i].address, Node1[i].data, Node1[N].address);
	}
	
}

---