6-4 单链表分段逆转

给定一个带头结点的单链表和一个整数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

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

---

作者并没有给出初始化函数和输出函数，所以我在调试的时候加上了，以下是完整代码

#define  _CRT_SECURE_NO_WARNINGS
#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;
}

void PrintList(List L)
{
    List p = L->Next;
    while (p != NULL)
    {
        printf(" %d", p->Data);
        p = p->Next;
    }
}

List ReadInput()
{
    List head = (Node*)malloc(sizeof(Node));      //  为头指针开辟内存空间
    List node = NULL;           //  定义结点
    List end = NULL;            //  定义尾结点
    head->Next = NULL;              //  初始化头结点指向的下一个地址为 NULL
    end = head;                     //  未创建其余结点之前，只有一个头结点
    int count = 0;                 //  结点个数
    printf("Input node number: ");
    scanf("%d", &count);
    for (int i = 0; i < count; i++) {
        node = (Node*)malloc(sizeof(Node));          //  为新结点开辟新内存
        int temp;
        scanf("%d", &temp);
        node->Data = temp;                                  //  新结点的数据域赋值
        end->Next = node;
        end = node;
    }
    end->Next = NULL;
    return head;
}

void K_Reverse(List L, int K)
{
    List lastre = L;// 上一次倒序到了的位置
    List latest = L;// 当前检查到的位置

    List final = (struct Node*)malloc(sizeof(struct Node));// 最终的存储位置
    final->Next = NULL;
    List final_rear = final;// final的尾部

    int flag = 1;// 当前有足够元素

    while (1)
    {
        List re = (struct Node*)malloc(sizeof(struct Node));// 存放一次倒序的
        re->Next = NULL;
        List re_rear = re;// re的尾部

        for (int i = 0; i < K; i++)
        {
            List p = (struct Node*)malloc(sizeof(struct Node));// 存储数据

            if (latest->Next == NULL)// 元素不够倒序就跳出，不进行了
            {
                flag = 0;// 没有足够元素了
                break;
            }

            p->Data = latest->Next->Data;
            p->Next = re->Next;// 头插
            re->Next = p;
            if (i == 0)
                re_rear = p; // 记录尾部
            latest = latest->Next;// 检查下一个
        }
        if (!flag)// 这次元素不够
        {
            final_rear->Next = lastre->Next;// 剩下的元素接上
            break;
        }
        lastre = latest;// 更新倒序完成位置
        final_rear->Next = re->Next;// 放入倒序的数据
        final_rear = re_rear;// 更新尾部位置
    }
    L->Next = final->Next;
}

        思路应该算不上好思路……额外定义一个用来存储倒叙的链表，直接用头插法，进来就是倒序了，而后把这个放到最终的链表的尾部，这就算是一次完整的循环了，剩下的问题就是怎么判断剩下的是不是足够完成一次倒序了。我判断的思路是如果生成倒序的时候获得的有NULL，就直接跳出，然后把剩下的直接接到链表上。

       属于是思路也不算好，然后最后不用的空间也没有释放掉，如果不是题目要求是个函数的话其实可以再写个释放链表的，用一次释放一次，要不其实不太规范。里面应该也可以，但我实在懒得写了。

        以后有时间的话看看有没有更好的思路了

        对建立链表因为懒得写了，使用的另一个大佬的，链接附上，有问题的话可以联系我删除这篇。 创建单链表的头插法与尾插法详解-CSDN博客