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 (≤10​5​​) which is the total number of nodes, and a positive K (≤10​3​​). 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 [−10​5​​,10​5​​], 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

 #include <stdio.h>
 #include <string>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 using namespace std;
 const int maxn=;
 struct node{
     int data;
     int pos=;
     int address;
     int next;
     int rank;
 }nodes[maxn];
 vector<node> v;
 int n,k,root;
 bool cmp(node n1,node n2){
     if(n1.rank<n2.rank) return true;
     else if(n1.rank>n2.rank) return false;
     else{
         return n1.pos<n2.pos;
     }
 }
 int main(){
   scanf("%d %d %d",&root,&n,&k);
   for(int i=;i<n;i++){
     int first,data,next;
     scanf("%d %d %d",&first,&data,&next);
     node tmp;
     tmp.address = first;
     tmp.data = data;
     tmp.next = next;
     if(data<) tmp.rank=;
     else if(data<=k) tmp.rank=;
     else tmp.rank=;
     nodes[first]=tmp;
     //v.push_back(tmp);
   }
   int j=;
   while(root!=-){
       nodes[root].pos=j;
       v.push_back(nodes[root]);
     root=nodes[root].next;
     j++;
   }
   sort(v.begin(),v.end(),cmp);
   for(int i=;i<v.size();i++){
       if(i!=v.size()-){
           printf("%05d %d %05d\n",v[i].address,v[i].data,v[i+].address);
       }
       else {
           printf("%05d %d -1\n",v[i].address,v[i].data);
       }
   }
 }

注意点：看到只想着排序了，看大佬的方法真简单，直接三个vector，再合起来打印输出。

一开始最后第二个测试点，最后一个超时，超时是因为一开始存数据直接存在vector里，然后要得到正确的顺序每次都要遍历一遍整个vector，时间复杂度很高。而且最开始的pos其实设置的也是有问题的，直接根据输入顺序得到了，神奇的是结果居然前几个都是对的。

最后存储链表还是要用静态数组，不能用vector，找next太耗时