1074 Reversing Linked List

最新推荐文章于 2024-07-11 12:23:05 发布

就是爱喝百香果冷饮

最新推荐文章于 2024-07-11 12:23:05 发布

阅读量409

点赞数

CC 4.0 BY-SA版权

分类专栏： PAT

本文链接：https://blog.youkuaiyun.com/qq_37617419/article/details/88083085

PAT 专栏收录该内容

29 篇文章

订阅专栏

本文介绍了一个算法挑战，即如何在给定的链表中，按照指定长度K逆序子链表。通过遍历链表并记录每个节点的位置，然后重新排序输出逆序后的链表，实现了对链表的有效逆序。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1074 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 (≤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

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=100010;
struct Node
{
	int address,data,next;
	int order;//结点在链表上的序号，无效结点记为maxn 
}node[maxn];
bool cmp(Node a,Node b)
{
	return a.order<b.order;
}
int main()
{
  int begin,n,K,address;
	for(int i=0;i<maxn;i++)
	{
		node[i].order=maxn;//初始化全部为无效结点 
	}
	scanf("%d%d%d",&begin,&n,&K);//起始地址，结点个数，步长
	for(int i=0;i<n;i++)
	{
		scanf("%d",&address);
		scanf("%d%d",&node[address].data,&node[address].next);
		node[address].address=address;
	} 
	int p=begin,count=0;//count计数有效结点的数目
	while(p!=-1)//遍历链表找出单链表的所有有效结点 
	{
       node[p].order=count++;//结点在单链表中的序号
	   p=node[p].next;//下一个结点		
	} 
    sort(node,node+maxn,cmp);
    //有效结点为前count个结点
	n=count;
	//单链表生成
	for(int i=0;i<n/K;i++)
	{
		//枚举完整地n/K块
		for(int j=(i+1)*K-1;j>i*K;j--)
		{
			//第i块倒着输出
			printf("%05d %d %05d\n",node[j].address,node[j].data,node[j-1].address); 
		} 
		//每一块的最后一个结点的next地址的处理
		printf("%05d %d ",node[i*K].address,node[i*K].data);
		if(i<n/K-1)
		{
			//如果不是最后一块，就指向下一块的最后一个结点
			printf("%05d\n",node[(i+2)*K-1].address);
			
		}else
		{
			//是最后一块
			if(n%K==0)
				//恰好是最后一个结点，输出-1
				printf("-1\n");
			else
			{
				//剩下的不完整的块按原先的顺序输出
				printf("%05d\n",node[(i+1)*K].address);
				for(int i=n/K*K;i<n;i++)
				{
					printf("%05d %d ",node[i].address,node[i].data);
					if(i<n-1)
					{
						printf("%05d\n",node[i+1].address);
				
					}else
					{
						printf("-1\n");
					}
				} 
			}
		}
	} 
	return 0;
}