PAT A1133 Splitting A Linked List (25) [链表]

题目

Given a singly linked list, you are supposed to rearrange its elements so that all the negative values appear before all of the non-negatives, and all the values in [0, K] appear before all those greater than K. The order of the elements inside each class must not be changed. For example, given the list being 18→7→-4→0→5→-6→10→11→-2 and K being 10, you must output -4→-6→-2→7→0→5→10→18→11.
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 (<= 105) which is the total number of nodes, and a positive K (<=1000). 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 in [-105, 105], and Next is the position of the next node. It is guaranteed that the list is not empty.
Output Specification:
For each case, output in order (from beginning to the end of the list) the resulting linked list. Each node occupies a line, and is printed in the same format as in the input.
Sample Input:
00100 9 10
23333 10 27777
00000 0 99999
00100 18 12309
68237 -6 23333
33218 -4 00000
48652 -2 -1
99999 5 68237
27777 11 48652
12309 7 33218
Sample Output:
33218 -4 68237
68237 -6 48652
48652 -2 12309
12309 7 00000
00000 0 99999
99999 5 23333
23333 10 00100
00100 18 27777
27777 11 -1

题目分析

已知N个结点，将值为负数的结点放置在非负节点之前，将小于等于k的结点放置在大于k的结点之前

解题思路

思路 01

1. 用数组存放结点，用属性order记录结点在链表中的序号（初始化为3*maxn）
2. 依次遍历链表中结点
   2.1 如果结点值<0，结点序号设置为cnt1++
   2.2 如果结点值>=0&&<=k，结点序号设置为maxn+cnt2++
   2.3 如果结点值>k，结点序号设置为2*maxn+cnt3++
3. 按照order排序，并依次打印

思路 02

1. 用数组存放结点，用属性order记录结点在链表中的序号（初始化为3*maxn）
2. 依次遍历链表中结点
   2.1 依次遍历链表中结点，找到所有值<0的节点，存放于vector
   2.2 依次遍历链表中结点，找到所有值>=0&&<=k的节点，存放于vector
   2.3 依次遍历链表中结点，找到所有值>k的节点，存放于vector
3. 依次打印vector中结点

易错点

已知结点中存在无效结点（即不在链表中的结点）

Code

Code 01（最优）

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn=100010;
struct node {
	int adr;
	int data;
	int next;
	int order=3*maxn;
} nds[maxn];
bool cmp(node &n1,node &n2) {
	return n1.order<n2.order;
}
int main(int argc,char * argv[]) {
	int hadr,n,k,adr;
	scanf("%d %d %d",&hadr,&n,&k);
	for(int i=0; i<n; i++) {
		scanf("%d",&adr);
		scanf("%d %d",&nds[adr].data,&nds[adr].next);
		nds[adr].adr=adr;
	}
	int cnt1=0,cnt2=0,cnt3=0;
	for(int i=hadr; i!=-1; i=nds[i].next) {
		if(nds[i].data<0)nds[i].order=cnt1++;
		if(nds[i].data>=0&&nds[i].data<=k)nds[i].order=maxn+cnt2++;
		if(nds[i].data>k)nds[i].order=2*maxn+cnt3++;
	}
	sort(nds,nds+maxn,cmp);
	int cnt=cnt1+cnt2+cnt3; 
	for(int i=0; i<cnt-1; i++) {
		printf("%05d %d %05d
",nds[i].adr,nds[i].data,nds[i+1].adr);
	}
	printf("%05d %d -1
",nds[cnt-1].adr,nds[cnt-1].data);
	return 0;
}

Code 02

#include <iostream>
#include <vector>
using namespace std;
const int maxn=100010;
struct node {
	int adr;
	int data;
	int next;
} nds[maxn];
int main(int argc,char * argv[]) {
	int hadr,n,k,adr;
	scanf("%d %d %d",&hadr,&n,&k);
	for(int i=0; i<n; i++) {
		scanf("%d",&adr);
		scanf("%d %d",&nds[adr].data,&nds[adr].next);
		nds[adr].adr=adr;
	}
	vector<node> v,ans;
	for(int i=hadr; i!=-1; i=nds[i].next) {
		v.push_back(nds[i]);
	}
	for(int i=0; i<v.size(); i++) {
		if(v[i].data<0)ans.push_back(v[i]);
	}
	for(int i=0; i<v.size(); i++) {
		if(v[i].data>=0&&v[i].data<=k)ans.push_back(v[i]);
	}
	for(int i=0; i<v.size(); i++) {
		if(v[i].data>k)ans.push_back(v[i]);
	}
	for(int i=0; i<ans.size()-1; i++) {
		printf("%05d %d %05d
",ans[i].adr,ans[i].data,ans[i+1].adr);
	}
	printf("%05d %d -1
",ans[ans.size()-1].adr,ans[ans.size()-1].data);
	return 0;
}