1052 Linked List Sorting (链表排序)

A linked list consists of a series of structures, which are not necessarily adjacent in memory. We assume that each structure contains an integer key and a Next pointer to the next structure. Now given a linked list, you are supposed to sort the structures according to their key values in increasing order.

Input Specification:
Each input file contains one test case. For each case, the first line contains a positive N (<10^5​​ ) and an address of the head node, where N is the total number of nodes in memory and the address of a node is a 5-digit positive integer. NULL is represented by −1.

Then N lines follow, each describes a node in the format:

Address Key Next

where Address is the address of the node in memory, Key is an integer in [−100000,100000], and Next is the address of the next node. It is guaranteed that all the keys are distinct and there is no cycle in the linked list starting from the head node.

Output Specification:
For each test case, the output format is the same as that of the input, where N is the total number of nodes in the list and all the nodes must be sorted order.

Sample Input:

5 00001
11111 100 -1
00001 0 22222
33333 100000 11111
12345 -1 33333
22222 1000 12345

Sample Output:

5 12345
12345 -1 00001
00001 0 11111
11111 100 22222
22222 1000 33333
33333 100000 -1

题意：
给出N个结点的地址address、数据域data、指针域next、然后给出链表的首地址，要求把在这个链表上的结点按data值从小到大排序。

思路：
1.定义静态链表，开一个标志flag用以表示结点在链表中是否出现，flag = false表示无效结点（不在链表上的结点）
2.进行初始化，令flag都为false，表示初始状态下全都是无效结点
3.从链表首地址开始遍历链表，将有效节点的flag都置为true，并计数有效结点的个数
4.将结点排序，排序原则：只要有无效结点，就按flag从大到小排序，以把有效结点排到数组左端，否则，按数据域从小到大排序，然后输出。

注意：
1.题目可能会出现无效结点，即不在题目给出的首地址开始的链表上。
2.还有可能出现全都是无效结点的情况，这时候应该输出"0 -1"
3.可以直接用%05d格式输出，以在不足5位时在高位补0，但是-1不能这样输出，否则会输出-0001（而不是-1或-00001）

#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn = 100010;
struct Node     //定义静态链表(步骤1)
{
    int address, data, next;
    bool flag;  //结点是否在链表上
}node[maxn];

bool cmp(Node a, Node b)
{
    if(a.flag == false || b.flag == false)
        return a.flag > b.flag;     //只要有无效结点，就按flag从大到小排序，即把无效结点放到后面去
    else
        return a.data < b.data;     //如果都是有效结点，则按值从小到大排序
}

int main()
{
    for(int i = 0; i < maxn; i++)   //初始化为无效结点（步骤2）
        node[i].flag = false;
    int n, begin, address;
    scanf("%d%d", &n, &begin);  //结点个数、首地址
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &address);
        scanf("%d%d", &node[address].data, &node[address].next);
//        scanf("%d%d%d", &address, &node[address].data, &node[address].next); //这么写会出现超时、答案错误的情况
        node[address].address = address;
    }
    int count = 0, p = begin;
    while(p != -1)      //枚举链表，对flag进行标记，同时计数有效节点的个数（步骤3）
    {
        node[p].flag = true;
        count++;
        p = node[p].next;
    }
    if(count == 0)  //特殊情况 链表中没有结点时输出0 -1
        printf("0 -1");
    else
    {
        sort(node, node + maxn, cmp);   //筛选有效结点，并按data从小到大排序（步骤4）
        printf("%d %05d\n", count, node[0].address);
        for(int i = 0; i < count; i++)
        {
            if(i != count - 1)
                printf("%05d %d %05d\n", node[i].address, node[i].data, node[i+1].address);	//不能是node[i].next,那样就相当于输出了未排序之前结点的链接关系
            else
                printf("%05d %d -1\n", node[i].address, node[i].data);
        }
    }
    return 0;
}