02-线性结构3 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 (≤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.

#include <iostream>
#include<string>
#include <iomanip>
using namespace std;
#define MAXSIZE 1000010
#define HEAD 1000009

struct LNode {
	unsigned int Data;
	int Next;
};

int Reverse(struct LNode List[], int Length, int K, int head);
int Length(struct LNode List[]);

int main()
{
	unsigned int FirstAddr, N, K, Addr, data;
	int NextAddr;
	struct LNode List[MAXSIZE];
	unsigned int i;

	cin >> FirstAddr >> N >> K;
	List[HEAD].Next = FirstAddr;
	for (i = 0; i < N; i++) {
		cin >> Addr >> data >> NextAddr;
		List[Addr].Data = data;					//地址为下标
		List[Addr].Next = NextAddr;
	}

	List[HEAD].Next = Reverse(List, Length(List), K, HEAD);		//返回头节点

	for (i = List[HEAD].Next; i != -1; i = List[i].Next) {
		cout << setw(5) << setfill('0') << i << " " << List[i].Data << " ";
		if (List[i].Next >= 0) cout << setw(5) << setfill('0') << List[i].Next << endl;
		else cout << List[i].Next << endl;
	}
	
	return 0;
}

//翻转
int Reverse(struct LNode List[], int Length, int K, int head)
{
	int New, Old, Tmp, NewHead, t;
	int flag = 1;
	int cnt, i;
	for (i = 0; i < Length/K ; i++) {
		if (flag) {			//flag成立则为第一次翻转
			cnt = 1;	
			New = List[head].Next;
			Old = List[New].Next;
			while (cnt < K) {
				Tmp = List[Old].Next;
				List[Old].Next = New;
				New = Old;
				Old = Tmp;
				cnt++;
			}
			List[List[head].Next].Next = Old;		//第一次翻转的尾节点(翻转前头一个)连接下一次翻转的头节点
			NewHead = New;							//最后返回的头节点
			flag = 0;	
			head = List[head].Next;					//保存第一次翻转尾节点
		}
		else {				//第二次及以后次翻转
			cnt = 1;
			New = List[head].Next;
			Old = List[New].Next;
			while (cnt < K) {
				Tmp = List[Old].Next;
				List[Old].Next = New;
				New = Old;
				Old = Tmp;
				cnt++;
			}
			t = List[head].Next;		//临时存储第二次翻转尾节点
			List[head].Next = New;		//第一次翻转尾节点连接第二次翻转头节点
			head = t;					//头转尾
			List[head].Next = Old;		//尾节点连接下一次头节点
		}
	}

	return NewHead;
}

//有干扰节点,计算有效节点长度
int Length(struct LNode List[])
{
	int i, cnt = 0;
	for (i = List[HEAD].Next; i != -1; i = List[i].Next) {
		cnt++;
	} 
	return cnt;
}