02-线性结构3 Reversing Linked List

Posted 2021-01-12 shin0324

Given a constant K and a singly linked list L, you are supposed to reverse the links of every Kelements 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 (≤) which is the total number of nodes, and a positive K (≤) 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

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 
 4 typedef struct LNode * PtrToLNode;
 5 typedef PtrToLNode position;
 6 struct LNode{
 7     int address;
 8     int data;
 9     int next;
10     position rear;
11 };
12 typedef PtrToLNode List;
13 
14 //读入函数 
15 void readlist( List L, int N){
16     position p = L;
17     while(N--){
18         List temp = (List)malloc(sizeof(struct LNode));
19         temp->rear = NULL;
20         scanf("%d%d%d", &temp->address, &temp->data, &temp->next);
21         p->rear = temp;
22         p = p->rear;
23     }
24 }
25 
26 //排序函数 
27 int sortlist(List L, List L2, int First){
28     position now1 = L, now2 = L2, temp;
29     int Findnode = First, cnt=0;                  //Findnode记录下一个要寻找的node地址，cnt记录在链表中的节点个数 
30     while(Findnode!=-1){
31         while(now1->rear){                        //遍历L，寻找address与Findnode相同的节点
32             if(now1->rear->address==Findnode){    //找到了将其从L中删除，插入到L2中去 
33                 temp = now1->rear;
34                 now1->rear = now1->rear->rear;     
35                 temp->rear = NULL;
36                 now2->rear = temp;
37                 now2 = now2->rear;
38                 Findnode = temp->next;
39                 cnt++;
40                 break;                         
41             }
42             now1 = now1->rear;
43         }
44         now1 = L;                 //更新now1，每一次寻找都要从头遍历l 
45     }
46     return cnt;
47 }
48 
49 //逆转链表函数 
50 void reverselist(List L2, int cnt, int K){
51     //old、new_记录进行逆转的两个节点位置，p1、p2记录要与已逆转链表头尾相连的两个节点位置 
52     position old = L2->rear->rear, new_ = L2->rear, temp, p1 = L2, p2 = L2->rear;
53     if(K==1||cnt==1) return;             //K或者链表长度cnt等于1，不需要逆转，直接返回 
54     while(cnt>=K){
55         cnt -= K;
56         for(int count=1; count<K; count++){
57             temp = old->rear;            //temp记录未逆转链表的头节点
58             old->rear = new_;            //逆转 
59             old->next = new_->address;
60             new_ = old;          //向后移位 
61             old = temp;          //向后移位 
62         }
63         p1->rear = new_;
64         p1->next = new_->address; 
65         p2->rear = old;
66         if(old) p2->next = old->address;    
67         else break;
68         p1 = p2;
69         p2 = p2->rear;
70         new_ = old;
71         old = old->rear;
72     }
73 }
74 
75 //输出函数 
76 void print(List L){
77     position now = L->rear;
78     while(now){
79         if(now->rear==NULL) printf("%05d %d -1
", now->address, now->data); 
80         else printf("%05d %d %05d
", now->address, now->data, now->next);
81         now = now->rear;
82     }
83 }
84 
85 //主程序框架 
86 int main( ){
87     List L1, L2;
88     L1 = (List)malloc(sizeof(struct LNode));
89     L1->next = NULL;
90     L2 = (List)malloc(sizeof(struct LNode));
91     L2->rear = NULL;
92     int First, N, k, cnt;             //因为有可能有多余节点不在链表上，用cnt记录在链表上的节点个数 
93     scanf("%d%d%d", &First, &N, &k);
94     readlist(L1, N);
95     cnt = sortlist(L1, L2, First);
96     reverselist(L2, cnt, k);
97     print(L2);
98     return 0;
99 }