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

 我的代码：（数组做法）

#include <iostream>
#include <algorithm>

using namespace std;
int list[100010];
int node[100010][2];

int main()
{
	int cnm, n, k;
	cin >> cnm >> n >> k;
	int address, data, next;
	for (int i = 0; i < n; i++)
	{
		cin >> address >> data >> next;
		node[address][0] = data;
		node[address][1] = next;
	}
	int c = 0,first=cnm;
	while (first!=-1)
	{
		list[c++] = first;
		first = node[first][1];
	}
	int i = 0;
	while (i+k<=c)
	{
		reverse(list + i, list + i + k);
		i = i + k;
	}
	for ( i = 0; i < c-1; i++)
	{  //错因在这里 最后的这个i不能是for语句里定义的：for ( int i = 0; i < c-1; i++)这样是错的 for结束就释放掉了
		//因为for后面还要printf一次，那个i的值是接着for结束时i的值。
		printf("%05d %d %05d\n", list[i], node[list[i]][0], list[i + 1]);
	} //其实我知道是接着for语句结束时的i，但是就是这样细节 耽误时间 很细节
	printf("%05d %d -1\n", list[i], node[list[i]][0]);
	return 0;
	
}

链表做法： （未实现）

#include <iostream>
#include <iomanip>
#include <algorithm>
using namespace std;

#define maxsize 100001

typedef struct node
{
	int address;
	int data;
	int nextaddress;
	struct node *next;
}Node,*LinkedList;

struct arrnode
{
	int address;
	int data;
	int nextaddress;
}arrnode[maxsize];

int n,k,head_address;

void read()
{
	cin >> head_address >> n >> k;
	for (int i = 0; i < n; i++)
	{
		cin >> arrnode[i].address >> 
			arrnode[i].data >> arrnode[i].nextaddress;
	}
}

LinkedList init_linkedlist()
{
	LinkedList L = (LinkedList)malloc(sizeof(Node));
	L->next = NULL;
	
	LinkedList r = (LinkedList)malloc(sizeof(Node));
	r = L;
	
	int t = n,count=0;
	while (t--)
	{
		for (int i = 0; i < n; i++)
		{
			if ((arrnode[i].address==head_address)&&
						(head_address!=-1))
			{
				LinkedList s = (LinkedList)malloc(sizeof(Node));
				s->next = NULL;
				s->address=arrnode[i].address;
				s->data = arrnode[i].data;
				s->nextaddress = arrnode[i].nextaddress;
				r->next = s;
				r = s;
				count++;
				head_address = s->nextaddress;
				break;
			}
		}
	}
	n = count;
	return L;
}

void reverse(LinkedList head, int k)
{
	
	int count = n / k;
	while (count--)
	{
		LinkedList p1 = head->next, p2 = p1->next, tail = p1;
		while (--k)
		{
			
			LinkedList t = p2->next;
			p2->next = p1;
			p2->nextaddress = p1->address;
			p1 = p2;
			p2 = t;
		}
		head->next = p1;
		head->nextaddress = p1->address;
		tail->next = p2;
		tail->nextaddress = p2->address;
		head = tail;
		tail = p2;
	}
	
}

void print(LinkedList L)
{
	LinkedList p = L->next;
	while (p)
	{		
		cout << setfill('0') << right
			<< setw(5) << p->address << " ";
		cout << setw(1) << p->data << " ";
		if (p->nextaddress==-1)
		{
			cout << setfill(' ') <<left<< setw(5) <<p->nextaddress<< endl;
		}
		else
		{
			cout << setfill('0') << right<<setw(5) << p->nextaddress << endl;
		}
		
		p = p->next;
	}
}

int main()
{
	read();
	LinkedList L = init_linkedlist();
	//LinkedList L = (LinkedList)malloc(sizeof(Node));
	if (k!=1)
	{
		reverse(L, k);
	}

	print(L);

	return 0;
}