翻转静态链表

问题简述

先将链表递增排序，每k个翻转一次，不足k个则按序输出

难点

对于输出的处理

代码

#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn = 10010;
struct NODE{
    int adr;
    int data;
    int next;
    int order;
}node[maxn];

bool cmp(NODE a, NODE b) 
{
    return a.data < b.data;
}

int mian()
{
    for(int i = 0; i < maxn; i++)
    {
        node[i].order = maxn;   // maxn为无效结点
    }
    int begin, n, k;
    scanf("%d%d%d", &begin, &n, &k);
    int adr, data, next;
    for(int i = 0; i < n; i++)
    {
        scanf("%d%d%d", &adr, &data, &next);
        node[adr].adr = adr;
        node[adr].data = data;
        node[adr].next = next;
    }
    int p = begin, count = 0;
    while (p != -1)
    {
        node[p].order = count;
        p = node[p].next;
        count++;
    }
    sort(node, node + maxn, cmp);
    n = count;
    for(int i = 0; i < n / k; i++)
    {
        for(int j = (i + 1) * k - 1; j > i * k; j--) // 每组最多k个，反向输出k-1个
        {
            // 输出 当前的地址， 当前的值 反向后下一个的地址
            printf("%05d %d %05d\n", node[j].adr, node[j].data, node[j-1].adr);
        }
        // 输出当前组的最后一个
        printf("%05d %d ", node[i * k].adr, node[i * k].data);
        // 输出当前组的最后一个的下地址
        if( i < n / k - 1)  // 当不是最后一个完整组时
        {
            printf("%5d\n", node[(i + 2) * k - 1].adr); // 下一组翻转的首个地址
        }
        else
        {
            if(n % k == 0)
            {
                printf("-1\n");
            }
            else
            {
                // 不足一组则无需翻转
                printf("%5d\n", node[(i+1) * k - 1]);
                for(int i = (n / k) * k; i < n ; i++)
                {
                    printf("%05d %d", node[i].adr, node[i].data);
                    if( i + 1 == n)
                    {
                        printf("-1\n");
                    }
                    else
                    {
                        printf("%5d\n", node[i+1].adr); 
                    }
                }
                
            }
            
        }
    }
    return 0;
}