02-线性结构2. Reversing Linked List (25)

Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K = 3, then you must output 3→2→1→6→5→4; if K = 4, you must output 4→3→2→1→5→6.

Input Specification:

Each input file contains one test case. For each case, the first line contains the address of the first node, a positive N (<= 10⁵) which is the total number of nodes, and a positive K (<=N) which is the length of the sublist to be reversed. The address of a node is a 5-digit nonnegative integer, and NULL is represented by -1.

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

Address Data Next

where Address is the position of the node, Data is an integer, and Next is the position of the next node.

Output Specification:

For each case, output the resulting ordered linked list. Each node occupies a line, and is printed in the same format as in the input.

Sample Input:

00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

Sample Output:

00000 4 33218
33218 3 12309
12309 2 00100
00100 1 99999
99999 5 68237
68237 6 -1

之前一直挂在测试点5上，原因就是翻转之前对节点进行了排序，今天百度了一下，借鉴了网友kevin-ye的方法（原文：点击打开链接），直接将节点的地址作为数组的索引（类似键值对）用空间换取时间避免了排序。

网易云课堂中陈越老师提到为了避免用数组钻空子特意设置了几个不在链表中的节点。但是可以很简单地避开。

#include <stdio.h>
#include <malloc.h>

const int MAXSIZE = 100000;

struct Info
{
    int address;
    int data;
    int nextAddress;
};

int main(void)
{
    int initAddress = 0;
    int num_Node = 0;
    int reverse = 0;
    scanf("%d %d %d", &initAddress, &num_Node, &reverse);
    int data[MAXSIZE];
    int nextAddress[MAXSIZE];
    Info list[MAXSIZE];

    int address = 0;
    for (int i = 0; i < num_Node; i++)
    {
        scanf("%d", &address);
        scanf("%d %d", &data[address], &nextAddress[address]);
    }
    int indexAddress = initAddress;

    int listSize = 0;
    while (indexAddress != -1)
    {
        list[listSize].address = indexAddress;
        list[listSize].data = data[indexAddress];
        list[listSize].nextAddress = nextAddress[indexAddress];

        listSize++;
        indexAddress = nextAddress[indexAddress];
    }

    // Reverse
    int restNode = listSize % reverse;
    int num_Group = listSize / reverse;
    // listSize % reverse == 0 or listSize == reverse
    if (restNode == 0)
    {
        for (int i = 0; i < num_Group; i++)
        {
            int j = reverse - 1;
            while (j >= 0)
            {
                int index = i * reverse + j;
                printf("%05d %d ", list[index].address, list[index].data);

                int next = 0;
                if (index % reverse == 0 && index + 2 * reverse - 1 <= listSize - 1)
                {
                    next = list[index + 2 * reverse - 1].address;
                }
                else if (index + reverse == listSize)
                {
                    next = -1;
                }
                else
                {
                    next = list[index - 1].address;
                }

                if (next != -1)
                {
                    printf("%05d\n", next);
                }
                else
                {
                    printf("-1\n");
                }
                j--;
            }
        }
    }
    // listSize % reverse > 0 and listSize > reverse
    else if (restNode > 0 && listSize > reverse)
    {
        for (int i = 0; i < num_Group; i++)
        {
            int j = reverse - 1;
            while (j >= 0)
            {
                int index = i * reverse + j;
                printf("%05d %d ", list[index].address, list[index].data);

                int next = 0;
                if (index % reverse == 0)
                {
                    if (index + 2 * reverse - 1 < listSize)
                    {
                        next = list[index + 2 * reverse - 1].address;
                    }
                    else
                    {
                        next = list[index + reverse].address;
                    }
                }
                else
                {
                    next = list[index - 1].address;
                }

                if (next != -1)
                {
                    printf("%05d\n", next);
                }
                // may redundant
                else
                {
                    printf("-1\n");
                }

                j--;
            }
        }

        int index = num_Group * reverse;
        while (index < listSize)
        {
            if (list[index].nextAddress != -1)
            {
                printf("%05d %d %05d\n", list[index].address,
                       list[index].data,
                       list[index].nextAddress);
            }
            else
            {
                printf("%05d %d %d\n", list[index].address,
                       list[index].data,
                       list[index].nextAddress);
            }
            index++;
        }
    }
    // listSize < reverse
    else if (listSize < reverse)
    {
        for (int i = 0; i < listSize; i++)
        {
            if (list[i].nextAddress != -1)
            {
                printf("%05d %d %05d\n", list[i].address,
                       list[i].data,
                       list[i].nextAddress);
            }
            else
            {
                printf("%05d %d %d\n", list[i].address,
                       list[i].data,
                       list[i].nextAddress);
            }
        }
    }

    return 0;
}