PAT B1025 反转链表 (25point(s))

最新推荐文章于 2022-02-21 16:40:33 发布

fffffffff_jj

最新推荐文章于 2022-02-21 16:40:33 发布

阅读量242

点赞数

分类专栏： PAT B

本文链接：https://blog.youkuaiyun.com/qq_42347617/article/details/104129413

版权

PAT B 专栏收录该内容

79 篇文章

订阅专栏

给定一个常数 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

思路 1：

设置一个计数器=k，每轮逆转k个节点，逆转n/k轮（Ps: n为有效节点个数，如果直接用总节点个数，最后一个点过不了）

要注意的点：
1）处理过的链表的起始位置需要记录（第一轮循环时，用first记录下来，后面循环不更新）
2）处理完一个子链后，处理下一个子链时，要保证这两个子链不断链（设一个额外的头节点subHead，一直指向上一子链的链尾节点（初始时任意指向一个用不到的位置），subHead->next一直指向下个子链的第一个节点）

三个指针：subHead，now（一直指向处理好的子链的链尾），next（指向下一个待处理节点）

整个过程就是：
每次把next指向的节点，摘下来插入到subHead后面，这个过程又要保证不断链

所以每轮循环的操作为：
1）先把now和next后面的节点接上：now->next = next->next
2）再把next用头插法插到最前面（subHead后）：（a、b顺序不可以颠倒！！）
- a）next->next = subHead->next;
- b）subHead->next = next;
3）更新next：next = now->next

如图：
code 1：

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 100010;
struct Node{
	int data, nex;
}node[maxn]; 
int getValid(int head){
	int cnt = 0;
	while(head != -1){	//计算有效节点个数 
		head = node[head].nex;
		cnt++;
	}
	return cnt;
}
int main(){
	int first, n, k, add;
	scanf("%d %d %d", &first, &n, &k);
	for(int i = 0; i < n; ++i){
		scanf("%d", &add);
		scanf("%d %d", &node[add].data, &node[add].nex);
	}
	int valid = getValid(first);
	int subHead = 100001;	//构造一个头节点 
	node[subHead].nex = first;
	int now, next;	//now指向的时已经处理好的子链的最后一个节点 
	for(int i = 0; i < valid/k; ++i){
		now = node[subHead].nex;
		int cnt = k-1; 
		while(cnt > 0){
			next = node[now].nex;	// no.1
			node[now].nex = node[next].nex; // no.2 
			node[next].nex = node[subHead].nex; // no.3 
			node[subHead].nex = next; // no.4
			cnt--;
		}
		//第一轮结束时：subHead的next就是第一轮遍历的最后一个节点，即逆转后整个链表的第一个节点
		if(i == 0) first = node[subHead].nex;	 
		subHead = now;	
	}
	int it = first;
	while(it != -1){
		if(node[it].nex != -1)
			printf("%05d %d %05d\n", it, node[it].data, node[it].nex);
		else printf("%05d %d %d\n", it, node[it].data, node[it].nex);
		it = node[it].nex;
	}
	return 0;
}

思路 2：有效节点存入vector中，先按规则走一遍编上号，再按编号排序，最后格式化输出

输入完遍历一遍，将每个节点按顺序编号，按编号sort（无效节点设为INF，排在后面）
注意点：
1)分块逆序输出每一块
2)处理块与块之间的连接
3)最后一块的处理

code 2:

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 100010;
struct Node{
	int address, data, next;
	int order;
	Node(){
		order = maxn;	//初始化为最大值 
	} 
}node[maxn]; 
bool cmp(Node a, Node b){
	return a.order < b.order;
}
int getValid(int head){
	int it = head, cnt = 0;
	while(it != -1){
		node[it].order = cnt++;
		it = node[it].next;
	}
	return cnt;
}
int main(){
	int first, n, k, add;
	scanf("%d %d %d", &first, &n, &k);
	for(int i = 0; i < n; ++i){
		scanf("%d", &add);
		scanf("%d %d", &node[add].data, &node[add].next);
		node[add].address = add;
	}
	int valid = getValid(first);
	sort(node, node+maxn, cmp);
	int start, end;
	if(valid % k != 0){	//最后一个节点不足k：顺序输出
		for(int i = 0; i < valid / k; ++i){
		//每一块倒序输出
			start = i * k + k - 1;
			end = i * k;
			for(int j = start; j > end; --j){
				printf("%05d %d %05d\n", node[j].address, node[j].data, node[j-1].address);
			}
			int nextS = (i + 2) * k - 1;
			//下一个块为最后一个
			if(i == valid / k - 1) nextS = start+1; 
			printf("%05d %d %05d\n", node[end].address, node[end].data, node[nextS].address); 
		}
		start = (valid / k) * k;
		end = valid-1;
		for(int i = start; i < end; ++i){
		 	printf("%05d %d %05d\n", node[i].address, node[i].data, node[i+1].address);
		}
		printf("%05d %d -1\n", node[end].address, node[end].data);	
	}else{
		for(int i = 0; i < valid / k; ++i){
		//每一块倒序输出
			start = i * k + k - 1;
			end = i * k;
			for(int j = start; j > end; --j){
				printf("%05d %d %05d\n", node[j].address, node[j].data, node[j-1].address);
			}
			int nextS = (i + 2) * k - 1;
			if(i != valid / k - 1) 
				printf("%05d %d %05d\n", node[end].address, node[end].data, node[nextS].address);
			else 
				printf("%05d %d -1\n", node[end].address, node[end].data);
		}
	}
	return 0;
}

code 2-2: 改进点

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 100010;
struct Node{
	int address, data, next;
	int order;
	Node(){
		order = maxn;	//初始化为最大值 
	} 
}node[maxn]; 
bool cmp(Node a, Node b){
	return a.order < b.order;
}
int getValid(int head){
	int it = head, cnt = 0;
	while(it != -1){
		node[it].order = cnt++;
		it = node[it].next;
	}
	return cnt;
}
int main(){
	int first, n, k, add;
	scanf("%d %d %d", &first, &n, &k);
	for(int i = 0; i < n; ++i){
		scanf("%d", &add);
		scanf("%d %d", &node[add].data, &node[add].next);
		node[add].address = add;
	}
	int valid = getValid(first);
	sort(node, node+maxn, cmp);
	int start, end;
	for(int i = 0; i < valid / k; ++i){
	//每一块倒序输出
		start = i * k + k - 1;
		end = i * k;
		for(int j = start; j > end; --j){
			printf("%05d %d %05d\n", node[j].address, node[j].data, node[j-1].address);
		}
		int nextS = (i + 2) * k - 1;
		if(valid % k != 0){	//最后一个节点不足k
			//下一个块为最后一个
			if(i == valid / k - 1) nextS = start+1; 
			printf("%05d %d %05d\n", node[end].address, node[end].data, node[nextS].address);
		}else{	//恰好分完 
			if(i != valid / k - 1) //不是最后一个块 
				printf("%05d %d %05d\n", node[end].address, node[end].data, node[nextS].address);
			else 
				printf("%05d %d -1\n", node[end].address, node[end].data);
		}
	}
	if(valid % k != 0){	//最后一个节点不足k：顺序输出最后一块 
		start = (valid / k) * k;
		end = valid-1;
		for(int i = start; i < end; ++i){
		 	printf("%05d %d %05d\n", node[i].address, node[i].data, node[i+1].address);
		}
		printf("%05d %d -1\n", node[end].address, node[end].data);	
	}
	return 0;
}

思路3：同思路2，更通用的思路，先按序存入vector（存有效元素地址），按要求存入vector ans中，格式化输入vector ans;

` T2 code:

#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct Node{
	int add, data, next;
}node[maxn];

void Print(vector<int> v){
	int last = v.size() - 1;
	for(int i = 0; i < v.size() - 1; ++i){
		printf("%05d %d %05d\n", v[i], node[v[i]].data, v[i+1]);
	}
	printf("%05d %d -1", v[last], node[v[last]].data);
}
int main(){
	int head, n, k;
	scanf("%d %d %d", &head, &n, &k);
	for(int i = 0; i < n; ++i){
		int t_add;
		scanf("%d", &t_add);
		scanf("%d %d", &node[t_add].data, &node[t_add].next);
		node[t_add].add = t_add;
	}
	vector<int> a, ans;
	while(head != -1){
		a.push_back(head);
		head = node[head].next;
	}
	int l = 0, r;
	while(l < a.size()){
		r = l + k;
		if(r <= a.size()){
			for(int i = r - 1; i >= l; --i){
				ans.push_back(a[i]);
			}
		}else{
			for(int i = l; i < a.size(); ++i){
				ans.push_back(a[i]);
			}
		} 
		l = r;
	}
	Print(ans);
	return 0;
}