leecode-C语言实现-25. K 个一组翻转链表

已于 2022-07-14 13:14:45 修改
阅读量362 收藏 1
点赞数 2
分类专栏： # leecode练习-c语言实现 文章标签： 链表 c语言 数据结构 leetcode 算法
于 2022-07-14 11:37:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45111959/article/details/125780468
版权

一、题目

在这里插入图片描述
在这里插入图片描述

二、解题思路

例如：
链表为：1 -> 2 -> 3 -> 4 -> 5。
步长为：3

（0）定义变量

TmpPoint：来记录当前的链表位置。
PreviousPoint：来记录上一个数组索引位为0的链表地址。
NextPoint：记录当前数组索引位为2的元素链接的下一个链表地址。
TmpArray：初始化一个长度为3的数组，里面存储链表中元素的指针。

（1）循环第一次

TmpPoint：&1
PreviousPoint：NULL
NextPoint：NULL
TmpArray：{&1，null，null}

（2）循环第二次

TmpPoint：&2
PreviousPoint：NULL
NextPoint：NULL
TmpArray：{&1，&2，null}

（3）循环第三次

TmpPoint：&3
PreviousPoint：NULL
NextPoint：&4
TmpArray：{&1，&2，&3}

将数组倒序遍历链接一遍，链表变为：3 -> 2 -> 1 -> 4 -> 5。

（4）循环第四次

TmpPoint：&4
PreviousPoint：&1
NextPoint：&4
TmpArray：{&4，null，null}

（5）循环第五次

TmpPoint：&5
PreviousPoint：&1
NextPoint：&4
TmpArray：{&4，&5，null}

由于元素已经全部遍历完，TmpPoint取下一个地址时取到NULL，退出循环，就得到最终结果啦。

三、VS2017-测试代码

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

#define STEP 2

struct ListNode 
{
    int val;
    struct ListNode *next;
};

typedef struct ListNode LN;

void SwapPoint(LN** TmpArray, LN* PreviousPoint, LN* NextPoint, int step);
struct ListNode* reverseKGroup(struct ListNode* head, int k);
LN* CreateList(int* TestArray, int TestArraySize);
void PrintList(LN* head);
void PrintArray(LN** TmpArray, int TmpArraySize);

int main()
{
    int TestArray[] = { 1,2,3,4,5 };
    int TestArraySize = sizeof(TestArray) / sizeof(int);
    LN* TestList = CreateList(TestArray, TestArraySize);
    PrintList(TestList);
    LN* ResList = reverseKGroup(TestList, STEP);
    PrintList(ResList);
}

/*
解法思路：
    例如：
    链表为：1 -> 2 -> 3 -> 4 -> 5。
    步长为：3

    定义两个变量head和next、tmp
    head：存储长度为3链表的头部指针，也就是1的指针，方便1指向4的地址。
    next：存储上一个链表的指针，先存1的地址，遍历到2时，指向1。
    tmp：存储当前指针。

由于我们不知道链表长度，上面这种方法适用于步长为链表长度的整数倍，所以我们换个思路。

我们可以生成一个步长为3的的数组，里面存储地址，如果长度不够直接返回头指针。
例如：[&1,&2,&3],然后再倒序进行连接。
1、定义变量HeadPoint记录&3。
2、定义变量NextPoint记录&4。
*/

struct ListNode* reverseKGroup(struct ListNode* head, int k) 
{
    if (head == NULL)
    {
        return NULL;
    }
    else if (k == 1)
    {
        return head;
    }
    LN** TmpArray = (LN**)malloc(sizeof(LN*) * k);
    LN* HeadPoint = NULL;
    LN* PreviousPoint = NULL;
    LN* NextPoint = NULL;
    LN* TmpPoint = head;
    int i = 0;
    int cnt = 0;

    do
    {
        TmpArray[i] = TmpPoint;
        TmpPoint = TmpPoint->next;
        printf("cnt : %d, i : %d\n", cnt, i);
        PrintArray(TmpArray, i+1);
        
        if (cnt == k - 1)
        {
            printf("Head:\n");
            HeadPoint = TmpArray[i];
            NextPoint = TmpArray[i]->next;
            PrintArray(TmpArray, k);
            SwapPoint(TmpArray, PreviousPoint,NextPoint, k);
            PreviousPoint = TmpArray[0];
            PrintList(HeadPoint);
            i = -1;
        }
        else if ( (i + 1) % k == 0)
        {
            printf("Continue:\n");
            NextPoint = TmpArray[i]->next;
            PrintArray(TmpArray, k);
            SwapPoint(TmpArray, PreviousPoint, NextPoint, k);
            PreviousPoint = TmpArray[0];
            PrintList(HeadPoint);
            i = -1;
        }
        i++;
        cnt++;
    } while (TmpPoint != NULL);
    
    free(TmpArray);
    return HeadPoint;
}

void SwapPoint(LN** TmpArray, LN* PreviousPoint,LN* NextPoint, int step)
{
    int i;
    if (PreviousPoint != NULL)
    {
        PreviousPoint->next = TmpArray[step - 1];
    }
    
    for ( i = step - 1; i >= 1; i--)
    {
        TmpArray[i]->next = TmpArray[i-1];
    }
    TmpArray[i]->next = NextPoint;
}


LN* CreateList(int* TestArray, int TestArraySize)
{
    int i;

    LN* head = (LN*)malloc(sizeof(LN));
    LN* p = (LN*)malloc(sizeof(LN));

    head->val = TestArray[0];
    head->next = NULL;
    p = head;

    for ( i = 1; i < TestArraySize; i++)
    {
        LN* q = (LN*)malloc(sizeof(LN));
        q->val = TestArray[i];
        q->next = NULL;
        p->next = q;
        p = q;
        //free(q);
    }
    //free(p);
    return head;
}

void PrintList(LN* head)
{
    printf("####################################\n");
    LN* p = (LN*)malloc(sizeof(LN));
    p = head;
    while (p != NULL)
    {
        printf("CurrentPoint : %p, val : %d, next : %p\n",p,p->val,p->next);
        p = p->next;
    }
    free(p);
    printf("####################################\n");
}

void PrintArray(LN** TmpArray,int TmpArraySize)
{
    printf("####################################\n");
    int i;
    for ( i = 0; i < TmpArraySize; i++)
    {
        printf("i : %d, val : %d, next : %p\n",i, TmpArray[i]->val, TmpArray[i]->next);
    }
    printf("####################################\n");
}

四、VS2017-测试结果

链表为：1 -> 2 -> 3 -> 4 -> 5。
步长为：2

最终结果为：
链表为：2 -> 1 -> 4 -> 3 -> 5。

C:\Users\czg>C:\Users\czg\source\repos\x64\Debug\C_TEST.exe
####################################
CurrentPoint : 0000022CCA186790, val : 1, next : 0000022CCA190E00
CurrentPoint : 0000022CCA190E00, val : 2, next : 0000022CCA190E50
CurrentPoint : 0000022CCA190E50, val : 3, next : 0000022CCA190C70
CurrentPoint : 0000022CCA190C70, val : 4, next : 0000022CCA190D60
CurrentPoint : 0000022CCA190D60, val : 5, next : 0000000000000000
####################################
cnt : 0, i : 0
####################################
i : 0, val : 1, next : 0000022CCA190E00
####################################
cnt : 1, i : 1
####################################
i : 0, val : 1, next : 0000022CCA190E00
i : 1, val : 2, next : 0000022CCA190E50
####################################
Head:
####################################
i : 0, val : 1, next : 0000022CCA190E00
i : 1, val : 2, next : 0000022CCA190E50
####################################
####################################
CurrentPoint : 0000022CCA190E00, val : 2, next : 0000022CCA186790
CurrentPoint : 0000022CCA186790, val : 1, next : 0000022CCA190E50
CurrentPoint : 0000022CCA190E50, val : 3, next : 0000022CCA190C70
CurrentPoint : 0000022CCA190C70, val : 4, next : 0000022CCA190D60
CurrentPoint : 0000022CCA190D60, val : 5, next : 0000000000000000
####################################
cnt : 2, i : 0
####################################
i : 0, val : 3, next : 0000022CCA190C70
####################################
cnt : 3, i : 1
####################################
i : 0, val : 3, next : 0000022CCA190C70
i : 1, val : 4, next : 0000022CCA190D60
####################################
Continue:
####################################
i : 0, val : 3, next : 0000022CCA190C70
i : 1, val : 4, next : 0000022CCA190D60
####################################
####################################
CurrentPoint : 0000022CCA190E00, val : 2, next : 0000022CCA186790
CurrentPoint : 0000022CCA186790, val : 1, next : 0000022CCA190C70
CurrentPoint : 0000022CCA190C70, val : 4, next : 0000022CCA190E50
CurrentPoint : 0000022CCA190E50, val : 3, next : 0000022CCA190D60
CurrentPoint : 0000022CCA190D60, val : 5, next : 0000000000000000
####################################
cnt : 4, i : 0
####################################
i : 0, val : 5, next : 0000000000000000
####################################
####################################
CurrentPoint : 0000022CCA190E00, val : 2, next : 0000022CCA186790
CurrentPoint : 0000022CCA186790, val : 1, next : 0000022CCA190C70
CurrentPoint : 0000022CCA190C70, val : 4, next : 0000022CCA190E50
CurrentPoint : 0000022CCA190E50, val : 3, next : 0000022CCA190D60
CurrentPoint : 0000022CCA190D60, val : 5, next : 0000000000000000
####################################

五、leecode提交代码

typedef struct ListNode LN;

void SwapPoint(LN** TmpArray, LN* PreviousPoint, LN* NextPoint, int step);

struct ListNode* reverseKGroup(struct ListNode* head, int k) 
{
    if (head == NULL)
    {
        return NULL;
    }
    else if (k == 1)
    {
        return head;
    }
    LN** TmpArray = (LN**)malloc(sizeof(LN*) * k);
    LN* HeadPoint = NULL;
    LN* PreviousPoint = NULL;
    LN* NextPoint = NULL;
    LN* TmpPoint = head;
    int i = 0;
    int cnt = 0;

    do
    {
        TmpArray[i] = TmpPoint;
        TmpPoint = TmpPoint->next;
        // printf("cnt : %d, i : %d\n", cnt, i);
        // PrintArray(TmpArray, i+1);
        
        if (cnt == k - 1)
        {
            // printf("Head:\n");
            HeadPoint = TmpArray[i];
            NextPoint = TmpArray[i]->next;
            // PrintArray(TmpArray, k);
            SwapPoint(TmpArray, PreviousPoint,NextPoint, k);
            PreviousPoint = TmpArray[0];
            // PrintList(HeadPoint);
            i = -1;
        }
        else if ( (i + 1) % k == 0)
        {
            // printf("Continue:\n");
            NextPoint = TmpArray[i]->next;
            // PrintArray(TmpArray, k);
            SwapPoint(TmpArray, PreviousPoint, NextPoint, k);
            PreviousPoint = TmpArray[0];
            // PrintList(HeadPoint);
            i = -1;
        }
        i++;
        cnt++;
    } while (TmpPoint != NULL);
    free(TmpArray);
    return HeadPoint;
}

void SwapPoint(LN** TmpArray, LN* PreviousPoint,LN* NextPoint, int step)
{
    int i;
    if (PreviousPoint != NULL)
    {
        PreviousPoint->next = TmpArray[step - 1];
    }
    
    for ( i = step - 1; i >= 1; i--)
    {
        TmpArray[i]->next = TmpArray[i-1];
    }
    TmpArray[i]->next = NextPoint;
}

六、leecode测试结果

在这里插入图片描述

阳光九叶草LXGZXJ
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
链表-使用C语言实现循环链表.zip
03-13
本资源“链表-使用C语言实现循环链表.zip”将详细介绍如何用C语言来创建和操作循环链表。 首先，我们要理解循环链表的基本概念。循环链表是一种链表，其最后一个节点的指针不是NULL，而是指向链表的第一个节点，...
链表-基于C语言实现的循环链表.zip
最新发布
06-28
链表 链表_基于C语言实现的循环链表
C语言：K个一组翻转链表
qq_37756688的博客
05-10 610
给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。 示例 : 给定这个链表：1->2->3->4->5 当 k = 2 时，应当返回: 2->1->4->3->5 当 k = 3 时，应当返回: 3->2->1-&g...
K个一组链表进行翻转
qq_51725723的博客
10-23 974
我们在第一步，寻找准备翻转链表的时候，循环完毕end的值应该指向的是准备翻转链表的最后一个节点，此时我们有声明了两个节点，分别是start和next，start保存的是准备翻转链表的头结点，next指向的是end->next，也就是下一组准备翻转链表的头结点，当看到这道题的时候，不自觉的让我想起了，翻转链表的那道题目，直接使用头插法，将链表翻转；这道题也应该是同理，我们将给定链表的每一组当做一个单独的链表，然后将其翻转，最后将反转之后的链表进行连接就可以得到结果。那么，实际操作一下吧！
LeetCode 25. K 个一组翻转链表（c语言实现）
qq_44243059的博客
07-02 246
LeetCode 25. K 个一组翻转链表（c语言实现）
k个一组翻转链表（力扣题目 C语言解法）
Enthusiastic_boy的博客
12-26 1275
目录 图示： 代码： 给你一个链表，每k个节点一组进行翻转，请你返回翻转后的链表。 k是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是k的整数倍，那么请将最后剩余的节点保持原有顺序。 示例 1： 输入：head = [1,2,3,4,5], k = 2 输出：[2,1,4,3,5] 示例 2： 输入：head = [1,2,3,4,5], k = 3 输出：[3,2,1,4,5] 示例 3： 输入：head = [1,2,3,4,5], k = ...
LeetCode_25_K个一组翻转链表
qq_36815750的博客
10-18 195
题目描述： 给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 示例 : 给定这个链表：1->2->3->4->5 当 k = 2 时，应当返回: 2->1->4->3->5 当 k = 3 时，应当返回: 3-&g...
链表-基于C语言实现的双向链表.zip
06-28
链表 链表_基于C语言实现的双向链表
C语言基础-C语言编程基础之Leetcode编程题解之第25题K个一组翻转链表.zip
04-27
第25题“K个一组翻转链表”要求用户实现一个函数，将给定的链表按照k个节点一组进行翻转，然后连接这些翻转后的子链表。 题目描述：给定一个链表和一个整数k，你需要按k个一组翻转链表的节点，如果剩余的节点不足k...
链表-基于C语言实现的单链表.zip
06-28
链表 链表_基于C语言实现的单链表
25. K 个一组翻转链表（最详细注释，分成三个步骤进行处理，简单易懂）
范大的博客
10-30 1032
25. K 个一组翻转链表（最详细注释，分成三个步骤进行处理，简单易懂）
K个一组翻转链表
乐只悠悠
05-30 3200
给你一个链表，每k个节点一组进行翻转，请你返回翻转后的链表。
C语言----链表中的节点每k个一组翻转
ftzchina的博客
08-28 300
题解：本题采用递归的方法 /** * struct ListNode { * int val; * struct ListNode *next; * }; */ class Solution { public: /** * * @param head ListNode类 * @param k int整型 * @return ListNode类 */ ListNode* reverseKGroup(ListNode*...
K 个一组翻转链表
程序员Forlan的博客
12-08 353
实现链表分组反转
[C++] k个一组反转链表
giturtle's blog
03-20 1468
目录例题描述解题思路代码实现 例题描述 此问题为反转单链表的引申问题之一，在单链表翻转的基础上增加一些边界控制，使链表完成k个节点一组的特殊化反转。最终返回反转后的链表头节点。 这里给出原问题链接：【反转一个单链表】https://blog.csdn.net/qq_42351880/article/details/88637387 此算法入参有两个：链表头节点、每组节点数k 示例： 输入: 1->2->3->4->5->6->NULL 如果参数k = 2， 输
[力扣c语言实现]25. k个一组翻转链表
dengwodaer的博客
05-25 495
25. k个一组翻转链表1. 题目描述2.代码如下 原题目连接 1. 题目描述 给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。 示例 : 给定这个链表：1->2->3->4->5 当 k = 2 时，应当返回: 2->1->4->...
Leetcode 25:k个一组翻转链表（最详细解决方案！！！）
热门推荐
coordinate的博客
06-14 1万+
给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。 示例 : 给定这个链表：1-&amp;gt;2-&amp;gt;3-&amp;gt;4-&amp;gt;5 当 k = 2 时，应当返回: 2-&amp;gt;1-&amp;gt;4-&amp;gt;3-&amp;gt;5 当 k = 3 时
K个一组反转链表
qq_39208237的博客
10-25 1721
K个一组反转链表 给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 题目解析 1.k个一组分别翻转，这就要我们要能对链表进行分组，每组是k个节点，各组单独翻转，意味着每组的翻转是组内行为，不可影响到别组，我在此处使用键值对pair将每组翻转前的头结点及尾结点存储起来 2.需要注意的是若节点总数不是k的倍数，多出的节点不翻转，那么需要设一个标志，标明存不存在不需要翻转的组
25、K个一组翻转链表
Rik_Liu的博客
03-08 197
作为一个菜鸟，最近在看《我的第一本算法书》，想在之前薄弱的基础上，多了解一点。虽然目前的工作重心不在算法上，但是多会一点总不是什么坏事 《我的第一本算法书》很通俗易懂，配了大量直白的图片，让我能够以很快的速度去了解之前没接触过的知识点， 但问题也在于过于通俗易懂了，跟看连环画一样，容易遗忘。因此在翻了一部分之后，回到前面，根据每一节的知识点，到LeetCode上找相应的题目来做，以加深理解。 ...
js实现k个一组翻转链表
06-10
好的，以下是 JavaScript 实现代码： ```javascript function reverseKGroup(head, k) { if (head === null || head.next === null || k < 2) { return head; } const dummy = new ListNode(0); dummy.next = head; let prev = dummy; let tail = dummy; while (true) { let count = k; while (count && tail) { count--; tail = tail.next; } if (!tail) { break; } head = prev.next; while (prev.next !== tail) { const curr = prev.next; prev.next = curr.next; curr.next = tail.next; tail.next = curr; } prev = head; tail = head; } return dummy.next; } ``` 其中，`ListNode` 是链表节点的定义，`head` 表示链表头节点，`k` 表示每 k 个节点进行一次反转。函数返回反转后的链表头节点。 具体实现过程参考了上面的步骤，其中 `prev` 表示当前处理的这一组节点的前驱节点，`tail` 表示当前处理的这一组节点的尾部。在每次处理一组节点时，我们先找到这一组节点的尾部 `tail`，然后使用类似于反转单链表的方式将这一组节点进行反转，并将反转后的一组节点连接到新链表的尾部。最后更新 `prev` 和 `tail` 指针，继续处理下一组节点，直到遍历完整个原链表。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值