PAT a1133

目的：按照要求分类，然后重新排序。类里面顺序不变。

输入：

第一行  第一个节点的地址

N  <=100000  节点数目

K   <=1000   第二类元素的分界线[0,K]

节点的地址是一个5位的非负整数，NULL被表示为-1

节点格式：

地址  数据  下一个

地址是节点的位置，数据是节点的值[-100000,100000],

下一个是下一个节点的位置

输出：

输出要求的顺序。每个节点一行，按照输入的格式。

算法：

用数组存结构体节点，里面有本来的顺序，再将结构体分类。

然后再排序输出。

#include<cstdio>
#include<algorithm>
#include<vector>
#include<unordered_map>

using namespace std;

const int maxn = 100010;

struct node{
    int ad;
    int val;
    int tag;
    int next;
    int r;
};

int N,K,root;
vector<node> A,B;
unordered_map<int,int> m;

bool cmp(node a,node b)
{
    if(a.tag!=b.tag)
        return a.tag>b.tag;
    else
        return a.r<b.r;
}

int main()
{
    scanf("%d%d%d",&root,&N,&K);

    for(int i=0;i<N;i++)
    {
        int ad,data,next;
        scanf("%d%d%d",&ad,&data,&next);
        m[ad] = i;
        A.push_back(node{ad,data,0,next,0});
        if(data<0)
        {
            A[i].tag = 3;
        }else if(data<=K&&data>=0)
        {
            A[i].tag = 2;
        }else if(data>K)
        {
            A[i].tag = 1;
        }
    }
    int cnt = 0;
    while(root!=-1)
    {
        int u = m[root];
        A[u].r = cnt++;
        B.push_back(A[u]);
        root = A[u].next;
    }
    sort(B.begin(),B.end(),cmp);
    for(int i=0;i<B.size();i++)
    {
        printf("%05d %d ",B[i].ad,B[i].val);
        if(i!=B.size()-1)
        {
            printf("%05d\n",B[i+1].ad);
        }else
        {
            printf("-1\n");
        }
    }
    return 0;
}

反思：要把要处理的链表上的点和杂点分离出来。要注意，sort不是稳定排序。