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

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

标签（空格分隔）： 数据结构 算法竞赛

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

哇，今天这道题真是恶心到我了。我最开始用的动态链表写的，但是我发现写到交换时就写不下去了，指针错综复杂，不可能指对，除非用递归，但是难度太大了。看了好几个答案后才知道，用静态链表做才是正确的思路。接下来就比较简单了。

但是要注意，会存在不在链表上的节点。这时候，我们就要找出主链的长度，以它作为for循环交换的界限。考虑到交换后地址的规律性，输出方式就简单多了。最后，别忘了还要将最后一个元素特殊考虑，分开输出。下面是AC的静态链表代码，以及写不下去的动态链表代码。

//下面是静态链表的正解
#include <iostream>
#include <algorithm>
using namespace std;
struct SL{
int data;
int nex;
}SL[100000];

int main()  {
int address0,data0,k;
cin >> address0 >> data0 >> k;
int dat=data0;
while (dat--) {
int ad,da,ne;
cin >> ad >> da >> ne;
SL[ad].data=da;
SL[ad].nex=ne;
}
int List[100000];
int p=address0,i=1;
while (p!=-1) {
List[i++]=p;
p=SL[p].nex;
}
for (int j=1;j+k<=i;j+=k)
reverse(List+j,List+j+k);
int j=1;
for (j=1;j<i-1;j++)
printf("%05d %d %05d\n",List[j],SL[List[j]].data,List[j+1]);
printf("%05d %d -1\n",List[j],SL[List[j]].data);
return 0;
}

//下面这段代码思路是错的，我想用动态链表做，但是太难了，而且可能直接就写不出来。用静态链表就简单多了
/*
#include <iostream>
#include <algorithm>
using namespace std;
typedef int first;
typedef int next;
typedef struct LL *PtoLL;
typedef struct LL   {
int des;
int data;
int nextdes;
PtoLL Front;
PtoLL Behind;
}LL;

int cmp(const void *a,const void *b){
PtoLL aa=(PtoLL)a;
PtoLL bb=(PtoLL)b;
return (aa->data-bb->data);
}

int main()  {
int des0,data0,nextdes0;
scanf("%d %d %d",&des0,&data0,&nextdes0);
PtoLL newL=(PtoLL)malloc(sizeof(LL)),head;
newL->Front=NULL;
head=newL;
while (data0--) {
int dest,datat,nextdest;
scanf("%d %d %d",&dest,&datat,&nextdest);
PtoLL newLt=(PtoLL)malloc(sizeof(LL));
newLt->des=dest;
newLt->data=datat;
newLt->nextdes=nextdest;
newLt->Front=newL;
newL->Behind=newLt;
newL=newL->Behind;
}
newL->Behind=NULL;
newL=head->Behind;
qsort(head,data0,sizeof(LL),cmp);
while (newL!=NULL)
{
printf("%d %d %d\n",newL->des,newL->data,newL->nextdes);
newL=newL->Behind;
}
return 0;
}
*/