[pta]02-线性结构3 Reversing Linked List (25分)

02-线性结构3 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 LLL 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^5​​) which is the total number of nodes, and a positive K (≤N\le N≤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 NNN 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

以下我的方法是有序数组，在排序的时候占用过多时间，主要的翻转时间其实是不多的。
用时间换空间时间复杂度在n^2.导致运行超时。看到了别人的方法,取消了排序的步骤，用数组模拟内存，数组序号代表地址。使用了后面的代码，但是对于有多余结点不在链表上的情况不理解。

#include <stdio.h>
#include <stdlib.h>
struct LNode{
    int Address;
    int Data;
    int Next;
}LNode;

void LRead(int L,struct LNode *LHead);
void LPrint(struct LNode *LHead,int L);
void LSort(struct LNode *LHead,int L,int Address1st);
int main(){ 
    int L,K,Address1st;
    int t;
    t=L;
    scanf("%d%d%d",&Address1st,&L,&K);
    struct LNode LHead[L];
    LRead(L,&LHead);
    LSort(&LHead,L,Address1st);
    LPrint(&LHead,L);
    system("pause");
    return 0;
}

void LRead(int L,struct LNode *LHead){
    int t = L;
    while(t!=0){
    scanf("%d%d%d",&LHead[L-t].Address,&LHead[L-t].Data,&LHead[L-t].Next);
        t--;
    }
    return;
}

LSort(struct LNode *LHead,int L,int Address1st){

    struct LNode tmpList[L];
    int i,j;
    for(i=0;i<L;i++){
        if(LHead[i].Address==Address1st){
            tmpList[0]=LHead[i];
        }
    }
    for(i=0;i<L;i++){
        if(tmpList[i].Next==-1)break;
        for(j=0;j<L;j++){
            if(LHead[j].Address==tmpList[i].Next){
                //printf("tmpList[%d+1]=LHead[%d]\n",i,j);
                tmpList[i+1]=LHead[j];
                break;
            }
        }
    }
    for(j=0;j<L;j++){
        LHead[j]=tmpList[j];
    }

}



void LPrint(struct LNode *LHead,int L){
    int i = L;
    while(i!=0){
        if(LHead[L-1].Next<0){
            printf("%05d %d %d\n",LHead[L-i].Address,LHead[L-i].Data,LHead[L-i].Next);
        }else{          
            printf("%05d %d %05d\n",LHead[L-i].Address,LHead[L-i].Data,LHead[L-i].Next);
        }
        i--;
    }
    return ;
}

测试例子

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

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

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

修改后

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

struct Node{   
    int Data;  
    int Next;  
};  
void Read(struct Node *Space,int N);
void LPrint(struct Node *Space,int Address1st);
int Reverse(struct Node *Space,int Address1st,int K,int N);


int main(){  
    int Address1st, N, K; 
    struct Node Space[MAXN]; 
    //printf("&Address1st, &N, &K\n");
    scanf("%d%d%d", &Address1st, &N, &K);
    Read(&Space,N);
    //LPrint(&Space,Address1st);
    Address1st=Reverse(&Space,Address1st,K,N);
    LPrint(&Space,Address1st);
    system("pause");
    return 0;  
}  


void Read(struct Node *Space,int N){
    int Address;
    while(N!=0){
        scanf("%d",&Address);
        scanf("%d%d",&Space[Address].Data,&Space[Address].Next);
        N--;
    }
    //printf("read end\n");
    return ;
}
void LPrint(struct Node *Space,int Address1st){
    int Address = Address1st;
    while(Space[Address].Next!=-1){
        printf("%05d %d %05d\n",Address,Space[Address].Data,Space[Address].Next);
        Address=Space[Address].Next;
    }
    printf("%05d %d %d\n",Address,Space[Address].Data,Space[Address].Next);

    return;
}
int Reverse(struct Node *Space,int Address1st,int K,int N){
    //printf("reverse start\n");
    int Address=Address1st,tempAddress,CellAddress;
    int n=N/K,i,j,x;
    int arr[n*K];
    //printf("Address1st:%d,K:%d,N:%d,n:%d\n",Address1st,K,N,n);
    for(j=0;j<n*K;j++){
            arr[j]=Address;
            Address=Space[Address].Next;
        }
    for(i=0;i<n;i++){

        //printf("i:%d\n",i);
        for(j=0;j<K;j++){
            //
            //printf("j:%d\n",j);
            x = i*K+j;
            if(j==0){

                if(n-i==1){
                    Space[arr[x]].Next=Space[arr[x+K-1]].Next;
                }else{
                    Space[arr[x]].Next=arr[x+2*K-1];
                }

            }else{
                Space[arr[x]].Next=arr[x-1];

            }
            //printf("%05d\t%d\t%d\n",arr[x],Space[arr[x]].Data,Space[arr[x]].Next);
            //system("pause");
        }

    }
    //printf("reverse end\n");
    Address1st=arr[K-1];
    return Address1st;
}