PAT A1074 Reversing Linked List
### 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
- 思路 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;
}
- T3 code: 模板
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct Node
{
int data, nex;
}node[maxn];
void Print(vector<int> & v)
{
if(v.size() != 0)
{
for(int i = 0; i < v.size(); ++i)
{
if(i < v.size()-1)
printf("%05d %d %05d\n", v[i], node[v[i]].data, v[i+1]);
else
printf("%05d %d -1", v[i], node[v[i]].data);
}
}
}
int main()
{
int head, n, k;
scanf("%d %d %d", &head, &n, &k);
for(int i = 0; i < n; ++i)
{
int tadd;
scanf("%d", &tadd);
scanf("%d %d", &node[tadd].data, &node[tadd].nex);
}
int cnt = 0;
vector<int> ans;
while(head != -1)
{
ans.push_back(head);
if(++cnt % k == 0)
{
reverse(ans.end()-k, ans.end());
}
head = node[head].nex;
}
Print(ans);
}
- T4 code:
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct Node
{
int data, nex;
}node[maxn];
void Print(vector<int> v)
{
if(v.size() != 0)
{
for(int i = 0; i < v.size(); ++i)
{
if(i < v.size()-1) printf("%05d %d %05d\n", v[i], node[v[i]].data, v[i+1]);
else printf("%05d %d -1", v[i], node[v[i]].data);
}
}
}
int main()
{
int first, n, k;
scanf("%d %d %d", &first, &n, &k);
for(int i = 0; i < n; ++i)
{
int add;
scanf("%d", &add);
scanf("%d %d", &node[add].data, &node[add].nex);
}
int head = first, cnt = 0;
vector<int> ans;
while(head != -1)
{
ans.push_back(head);
head = node[head].nex;
}
int left = 0, right = left + k;
while(right <= ans.size())
{
reverse(ans.begin()+left, ans.begin()+right);
left = right;
right = left + k;
}
Print(ans);
return 0;
}
扫一扫
127
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
