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

线性结构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 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^​5​ ) 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

//本题要用数组模拟内存，用序号代表地址
#include<stdio.h>
#include<stdlib.h>
#pragma warning(disable:4996);//防止VS调试报错
typedef struct LinkedListNode* LinkedList;
const int MAXSIZE=100002;//数组(即“内存”)大小,[100001]位置用来表示临时头结点
struct LinkedListNode{
    int x;//节点存储的
    int next;//下一个节点的“地址”
};

LinkedList read(int num){
    LinkedList list=(LinkedList)malloc(MAXSIZE*sizeof(struct LinkedListNode));
    int addr,next,x;
    while(num--){
        scanf("%d %d %d",&addr,&x,&next);
        list[addr].x=x;
        list[addr].next=next;
    }
    return list;
}

int count(LinkedList list,int first){
    int num=1;
    for(int here=first;(list+here)->next!=-1;num++)
        here=(list+here)->next;
    return num;
}

void print_list(const LinkedList list,int first){
    int serialNum=first;//offset，即节点所在位置
    while(list[serialNum].next!=-1){
        //printf("%[flags] [width] [.precision] [{h | l | I64 | L}]type")
        //其中flags是指正负号和前导0或空格
        printf("%05d %d %05d\n",serialNum,list[serialNum].x,list[serialNum].next);
        serialNum=list[serialNum].next;//"指针"指向下一个节点        
    }
    printf("%05d %d %d\n",serialNum,list[serialNum].x,list[serialNum].next);//输出最后一个结点
}

//返回
int reverse(LinkedList list,int head,int length,int k){
    int segments=length/k;
    int preTail=MAXSIZE-1;//用来表示上一段链表逆序后的尾结点
	list[preTail].next = head;//初始化空头结点链接至待逆序链表
    int thisHead=head;//本段当前头结点,亦即重拍后链表段的尾结点
    while(segments--){
        //头插法逆序链表
        for(int i=0;i<k-1;i++){
            int target=list[thisHead].next;//待插入节点在已逆序链表段尾的下一个
            list[thisHead].next=list[target].next;//已逆序链表段尾链接到未排序段头
            list[target].next=list[preTail].next;//待插入节点指向已逆序链表段头
            list[preTail].next=target;//上段尾结点指向本段新头结点，即target
        }
        preTail=thisHead;//本段的新尾结点诞生
        thisHead=(list+thisHead)->next;//thisHead指向下一段的开头
    }
    return list[MAXSIZE-1].next;
}

int main(){
    int head,num,k;//链表头“地址”，输入节点数，逆序长度
    scanf("%d %d %d",&head,&num,&k);
    LinkedList list=read(num);//读取输入，创建链表
    int length=count(list,head);//获得链表实际长度
    //print_list(list,head);
    int newHead=reverse(list,head,length,k);//逆转链表并获得新头结点
    print_list(list,newHead);
    return 0;
}