PTA 单链表分段逆转

Posted 2020-11-22 dirwang

6-9 单链表分段逆转 (25 分)

 

给定一个带头结点的单链表和一个整数K，要求你将链表中的每K个结点做一次逆转。例如给定单链表 1→2→3→4→5→6 和 K=3，你需要将链表改造成 3→2→1→6→5→4；如果 K=4，则应该得到 4→3→2→1→5→6。

函数接口定义：

void K_Reverse( List L, int K );

其中List结构定义如下：

typedef struct Node *PtrToNode;
struct Node {
    ElementType Data; /* 存储结点数据 */
    PtrToNode   Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

L是给定的带头结点的单链表，K是每段的长度。函数K_Reverse应将L中的结点按要求分段逆转。

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;

typedef struct Node *PtrToNode;
struct Node {
    ElementType Data; /* 存储结点数据 */
    PtrToNode   Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

List ReadInput(); /* 裁判实现，细节不表 */
void PrintList( List L ); /* 裁判实现，细节不表 */
void K_Reverse( List L, int K );

int main()
{
    List L;
    int K;

    L = ReadInput();
    scanf("%d", &K);
    K_Reverse( L, K );
    PrintList( L );

    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

6
1 2 3 4 5 6
4

输出样例：

4 3 2 1 5 6

 1 void K_Reverse( List L, int K ){
 2    PtrToNode r, p, end1,end2 ,H = L->Next;//_ 1 2 3 4 5 6 7 8 9 10  11 12    
 3     /**end1和end2是用来连接两个逆置后的分段；
 4        一开始我们令end1指向头节点，end2指向数据1所在的节点，为什么这样做呢？
 5        因为前四个数据我们都要把他以头插入方式插到L后面，也就是end1后面；
 6        当我们遍历到节点5的时候我们需要令end1 = end2；end2 = 5所在的节点；
 7        然后我们需要将5 6 7 8再以头插入的方式插入到1节点的后面，也就是end1的后面
 8        也就是说我们一直将节点以头插入的方式插入到end1后面，而end2使用来记录下一个
 9        分段的第一个节点，也就是下一个end1，就这样不断更新end1就可以实现将整个链表
10        分段逆置；这是end1和end2的作用
11     */
12     end1 = L;
13     end2 = L->Next;
14     r = L->Next;    //用来遍历链表
15     p = r->Next;    
16     int count = 0;      
17     /**
18         count用来记录链表节点总数；
19         为什么要记录总数？
20         因为我们要知道链表最后一个分段是不足K个节点，还是刚好K个节点；
21         如果不足就不用逆置，如果刚好也要把这一分段逆置了；
22     */
23     if (K>=1)            //这里就是我上面说的考虑K的情况
24     {    
25         //记录总数
26         while (H)        
27         {            
28         count++;            
29         H = H->Next;        
30         }
31                 
32         //判断，如果总数小于K就不变链表
33         if (count>=K)        
34         {
35                /**count/K是我们总共需要循环几个分段，因为count/K结果去商，
36                   所以如果count不能被K整除，即最后一个分段不足K个，我们就不循环
37                   也就是不动它。
38                */            
39             for (int j = 0;j<count/K;j++)            
40             {                
41                 //每个分段循环K次
42                 for(int i = 0; i < K; i++)                
43                 {                    
44                     r->Next = end1->Next;    //头插入
45                     end1->Next = r;
46                     r = p;
47                     /**
48                      这里为什么要判断p不为空呢？
49                      因为我一开令r = L->Next;
50                              p = r->Next;
51                      所以最后p会指向链表最后的Next域，而Next为空，就不
52                      存在p的Next域，如果不判断的话程序运行到此处就不会再运行下去
53                      而程序一开始编译的时候不会报错，所以这一点很重要，即判断越界
54                      问题，我也是找了很长时间才找点这一点。
55                     */                      
56                     if(p)
57                         p = p->Next;                
58                  }
59                 end1 = end2;    //更新end1和end2                
60                 end2 = r;            
61             }            
62             end1->Next = r;    //最后将尾节点Next域置空。
63         }
64     }
65 
66 }