PAT乙级1075：链表元素分类(25）

题目

给定一个单链表，请编写程序将链表元素进行分类排列，使得所有负值元素都排在非负值元素的前面，而 [0, K] 区间内的元素都排在大于 K 的元素前面。但每一类内部元素的顺序是不能改变的。例如：给定链表为18→7→-4→0→5→-6→10→11→-2，K 为 10，则输出应该为 -4→-6→-2→7→0→5→10→18→11。

输入格式：
每个输入包含一个测试用例。每个测试用例第 1 行给出：第 1 个结点的地址；结点总个数，即正整数N (≤10⁵)；以及正整数K (≤10³)。结点的地址是 5 位非负整数，NULL 地址用 −1 表示。

接下来有 N 行，每行格式为：

Address Data Next
其中 Address 是结点地址；Data 是该结点保存的数据，为 [−10⁵,10⁵] 区间内的整数；Next 是下一结点的地址。题目保证给出的链表不为空。

输出格式：
对每个测试用例，按链表从头到尾的顺序输出重排后的结果链表，其上每个结点占一行，格式与输入相同。

输入样例：

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
结尾无空行

输出样例：

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
结尾无空行

解题思路

首先先构造结点的结构体数组，该数组运用hash散列的思想，元素的下标即为结点的首地址（需要注意的是，由于题意要求需要按照结点数值大小分段输出，且保持原链表先后顺序，结点结构体定义时需要增加记录数值所处的“段”和出现次序的变量，以便排序）；之后，遍历链表，记录出现顺序；最后排序后按指定格式输出。

难点

测试点4答案错误，该测试点检测的是：当输入结点存在“不在链表内、但仅按照结点数值大小排列又在一些有效结点之前”的结点。
解决：修正qsort的排序函数cmp。原来错误的逻辑是简单的判断rank（按照数值进行的分段）大小：将结点中数值处于<0的（rank=1）放在数值为[0,K]之间的结点（rank=2）之前，将数值大于K的结点（rank=3）放在数值为[0,K]之间的结点之后，未出现的结点记为4；如果两个结点rank相等，按照出现次序排列。cmp中基于以上错误逻辑的具体代码如下：

int cmp(const void *a, const void *b){
    struct node c = *(struct node*)a;
    struct node d = *(struct node*)b;
	if (c.rank!=d.rank)
    	return c.rank-d.rank;
	else
		return c.app-d.app;
}

基于上述逻辑的代码未考虑到：假如有结点值为-1，但它只是给出的结点，而不处于链表中，那么它也有可能因rank小而排列在有效结点的元素前被输出。
因此，在排列元素前，首先需要以出现次序来判断该元素是否在链表当中，假如在链表中，为有效结点，再按“rank > 出现次序”的顺序排序；假如该结点为无效结点，则排列在有效节点之后。修正后cmp的代码如下：

int cmp(const void *a, const void *b){
    struct node c = *(struct node*)a;
    struct node d = *(struct node*)b;
    if (c.app!=d.app)
    {
        if (c.app==100005)//未出现，放在有效节点之后
            return 1;
        else if (d.app==100005)//未出现，放在有效节点之后
            return -1;
        else//c、d都出现了
        {
            if (c.rank!=d.rank)
                return c.rank-d.rank;
            else
                return c.app-d.app;
        }
    }
    else//都未出现
        return c.rank-d.rank;
}

代码

//使得所有负值元素都排在非负值元素的前面，而 [0, K] 区间内的元素都排在大于 K 的元素前面
//但每一类内部元素的顺序是不能改变的
#include<stdio.h>
#include<stdlib.h>
struct node{
    int head;
    int tail;
    int content;
    int app;//记录出现次序
    int rank;//放在第i梯队
};

int cmp(const void *a, const void *b){
    struct node c = *(struct node*)a;
    struct node d = *(struct node*)b;
    if (c.app!=d.app)
    {
        if (c.app==100005)//未出现，放在有效节点之后
            return 1;
        else if (d.app==100005)//未出现，放在有效节点之后
            return -1;
        else//c、d都出现了
        {
            if (c.rank!=d.rank)
                return c.rank-d.rank;
            else
                return c.app-d.app;
        }
    }
    else//都未出现
        return c.rank-d.rank;
}

int main(){
    int first_add,n,K,i,temp[3],k = 0;//k记录出现顺序
    scanf("%d %d %d\n",&first_add,&n,&K);
    struct node N[100000];//hash散列
    for (i=0;i<100000;i++)
    {
        N[i].rank = 4;//表示未出现
        N[i].app = 100005;
    }
    for (i=0;i<n;i++)
    {
        scanf("%d %d %d\n",&temp[0],&temp[1],&temp[2]);
        N[temp[0]].head = temp[0];
        N[temp[0]].content = temp[1];
        N[temp[0]].tail = temp[2];
        if (temp[1]<0)
            N[temp[0]].rank = 1;
        else if (temp[1]>K)
            N[temp[0]].rank = 3;
        else
            N[temp[0]].rank = 2;
    }
    int sub = first_add;
    while (N[sub].tail!=-1){
        N[sub].app = k++;
        sub = N[sub].tail;
    }
    N[sub].app = k++;//补充最后一个元素的次数
    qsort(N,100000,sizeof(N[0]),cmp);//要对所有结点进行排序
    for (i=0;i<k;i++)
    {
        printf("%05d %d ",N[i].head,N[i].content);
        if (i!=(k-1))
            printf("%05d\n",N[i+1].head);
        else
            printf("-1\n");
    }
    return 0;
}