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 (≤103). 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

 #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太耗时