02-线性结构3 Reversing Linked List

　　这是我到目前为止这个习题集中花时间最久ac的题目了……其实一开始思路还是挺清晰的，但是有三个测试点很长时间通过不了，最终结合别人的方法对自己的代码进行了大改。

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 100001

typedef struct LNode *List;
struct LNode{
    int Addr;
    int Data;
    int NextAddr;
    List Next;
};

List FormList(int FirstAdd, int N, int *pn)
{
//    struct LNode LN[MaxSize];
    List head;
    int tmpAddr;  //as the index of the original array
    int i;
    int Addr[MaxSize], Data[MaxSize], NextAddr[MaxSize];
    struct LNode LN[N + 1];
    LN[0].NextAddr = FirstAdd;
    for(i = 0; i < N; i++){
        scanf("%d", &tmpAddr);
        scanf("%d %d", &Data[tmpAddr], &NextAddr[tmpAddr]);
    }
    i = 1;
    while(1){
        if(LN[i - 1].NextAddr == -1){
            LN[i - 1].Next = NULL;
            (*pn) = i - 1;
            break;
        }
        LN[i].Addr = LN[i - 1].NextAddr;
        LN[i].Data = Data[LN[i].Addr];
        LN[i].NextAddr = NextAddr[LN[i].Addr];
        LN[i - 1].Next = LN + i;  //?
        i++;
    }
    head = LN;
    return head;
}

void PrintList(List L)
{
    List p;
    p = L;
    while(p->Next){
        p = p->Next;
        if(p->NextAddr == -1)
            printf("%05d %d %d
", p->Addr, p->Data, p->NextAddr);
        else
            printf("%05d %d %05d
",p->Addr, p->Data, p->NextAddr );
    }
}

List Reverse(List head, int K)
{
    int cnt = 1;
    List newP, old, tmp;
    newP = head->Next;
    old = newP->Next;
    while(cnt < K){
        tmp = old->Next;
        old->Next = newP;
        old->NextAddr = newP->Addr;
        newP = old;
        old = tmp;
        cnt++;
    }
    head->Next->Next = old;
    if(old)
        head->Next->NextAddr = old->Addr;
    else
        head->Next->NextAddr = -1;
    return newP;
}

int main(int argc, char const *argv[])
{
    int FirstAdd, N, K;
    int i, j;
    int num = 0;
    int *pn = &num;
    List L;
    scanf("%d %d %d", &FirstAdd, &N, &K);
    L = FormList(FirstAdd, N, pn);
    List p, rp;
    p = L;
    rp = NULL;
    if(K <= num){
        for(i = 0; i < (num/K); i++){
            rp = Reverse(p, K);
            p->Next = rp;  //更新p
            p->NextAddr = rp->Addr;  //NextAddr的变换尤为重要
            for(j = 0; j < K; j++)
                p = p->Next;
        }
    }
    PrintList(L);
    return 0;
}

　　测试点“正好全反转”对应90 - 98行，当num是K的整数倍时，链表要每段都整体反转多次。

　　测试点“有多余结点不在链表上”对应num参数的操作，num代表输入的有效结点的个数，当输入一些链外结点时它们不会被计入有效结点，以保证循环次数的正确。

　　测试点“最大N，最后剩下K - 1不反转”除了需要考虑num数值以保证反转数的正确，还涉及了对时间复杂度的考察。这也是我最后一个通过的测试点，因为起先我的思路是把每组输入的内容都以结点形式存储下来：

List FormList(int FirstAdd, int N, int *pn)
{
    List L[MaxSize], head, tmp;
    int i, j;
    int Addr[MaxSize], Data[MaxSize], NextAddr[MaxSize];
    L[0] = (List)malloc(sizeof(struct LNode));
    //L[0] as the head node,
    //whose Data and Addr is null while Next points to the first valid node
    for(i = 1; i < N + 1; i++)
        scanf("%d %d %d", &Addr[i], &Data[i], &NextAddr[i]);
    for(i = 1; i < N + 1; i++){
        if(Addr[i] == FirstAdd){
            L[1] = (List)malloc(sizeof(struct LNode));
            L[1]->Addr = Addr[i];
            L[1]->Data = Data[i];
            L[1]->NextAddr = NextAddr[i];
            L[0]->Next = L[1];  //Now the first valid node was constructed and pointed by the head node
            (*pn)++; 
            break;
        }
    }
    i = 1;
    while(1){
        for(j = 1; j < N + 1; j++){
            if(L[i]->NextAddr == Addr[j]){
                (*pn)++;
                L[i + 1] = (List)malloc(sizeof(struct LNode));
                L[i + 1]->Addr = Addr[j];
                L[i + 1]->Data = Data[j];
                L[i + 1]->NextAddr = NextAddr[j];
                L[i]->Next = L[i + 1];
            }
        }
        if(L[i]->NextAddr == -1){
            L[i]->Next = NULL;
            break;
        }
        i++;
    }
    head = L[0];
    free(L[0]);
    return head;
}

　　这样虽然很明确对应了每个独立结点，也方便串联操作，但是构建时的时间复杂度已达到O(n²)，测试最大N时会超时，所以后来还是改用了数组方法，这才提升了操作效率。