对于静态链表解决排序问题的一般性方法

步骤1:定义静态链表

struct Node{
	int address;
	typename data;
	XXX;	//节点的某个性质，不同的题目会有不同的设置。
}node[100010];

步骤二：静态链表初始化。

一般来说需要对XXX性质进行初始化（一般来说就是小于所有能达到的数字或者false）

for(int i = 0; i < maxn; i++){
	node[i].XXX = -1;
}

步骤三：从头节点开始便利整条链表。

注意：这一步是我们对XXX性质进行标记的时候，并且对所有有效节点进行计数的时候。

int p = begin, count = 0;
while(p != -1){
	XXX = 1;
	count++;
	p = node[p].next;
}

步骤四：

由于采用的是静态链表，采用的是地址映射的方式，就会使得数组下标不连续，而题目给出的节点并非都是有效节点（有可能样例给出的是不存在于链表上的节点）。为了能够有效访问节点， 一般将节点移动到数组的最左端，这样可以用步骤三的count来对有效节点进行访问。
既然需要把有效节点移动到前面，那么就可以利用XXX性质。因此可以在编写sort的排序函数cmp的时候，就可以在cmp中两个参数节点由大到小排序，这样就可以把有效节点移动到左端
一般来说，题目还会有其他要求，那么就可以将其他要求放在cmp函数的二级排序

bool cmp(Node a, Node b){
	if(a.XXX == -1 || b.XXX == -1)
		return a.XXX > b.XXX;
	else{
		//二级排序。
	}
}

步骤五：

此时的有效节点已经全在左端，并且按照二级排序的顺序排序好了，这时候具体要做什么就是看题目要求了。

例题：

1052 Linked List Sorting (25 分)
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⁵) 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 [−10⁵,10⁵], 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
结尾无空行

题解：

#include <cstdio>
#include <algorithm>
using namespace std;
#define maxn 100010
struct Node{
    int address;
    int key;
    int next;
    int flag = -1;
}node[maxn];
bool cmp(Node a, Node b){
    if(a.flag == -1 || b.flag == -1){
        return a.flag > b.flag;
    }else{
        return a.key < b.key;
    }
}
int main(){
    int n, s;
    scanf("%d %d", &n, &s);
    int p = s;
    int add, key, next;
    for(int i = 0; i < n; i++){
        scanf("%d %d %d", &add, &key, &next);
        node[add].address = add;
        node[add].key = key;
        node[add].next = next;
        //node[add].flag = 1;
    }
    int count = 0;
    while(p != -1){
        node[p].flag = 1;
        count++;
        p = node[p].next;
    }
    if(count == 0){
        printf("0 -1");
    }else{
        sort(node, node+maxn, cmp);
        /*p = node[0].address;
        while(p != -1){
            printf("%05d %d %05d\n",p,node[p].key,node[p].next);
            p = node[p].next;
        }*/
        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].key,node[i+1].address);
            else
                printf("%05d %d -1\n", node[i].address,node[i].key);
        }
    }
    return 0;
}