链表不需要事先估计存储空间,链表表示线性表的优点

　　BM3-链表中的节点每k个一组翻转描述将给出的链表中的节点每k个一组翻转，返回翻转后的链表

　　如果链表中的节点数不是k的倍数，将最后剩下的节点保持原样

　　你不能更改节点中的值，只能更改节点本身。

　　数据范围：链表中每个元素都满足

　　要求空间复杂度，时间复杂度例如：给定的链表是对于，你应该返回对于，你应该返回

　　示例一输入：

　　{1,2,3,4,5},2

　　返回值：

　　{2,1,4,3,5}

　　示例2输入：

　　{},1

　　返回值：

　　{}

　　实现思路：

　　和BM2一样，只需要实现一个反向_n函数，然后借助该函数即可解决题目

　　#包含位/标准数据h。

　　结构列表节点

　　{

　　int值

　　结构列表节点*下一个

　　};

　　类别解决方案

　　{

　　公共：

　　/**

　　*

　　* @param head ListNode类

　　* @param m int整型

　　* @param n int整型

　　* @返回列表节点类

　　*/

　　静态ListNode * reverse group(ListNode * head，int k)

　　{

　　if (k=1 head==nullptr)

　　{

　　回程头；

　　}

　　auto cur _ node=头

　　auto next _ node=head-next；

　　//这里使用希腊字母的第11个表达式，是为了捕获相关状态，避免写函数返回值，说白了就是懒！

　　auto reverse_n=[ cur_node，next_node](ListNode *head，int n)

　　{

　　//检查长度是否足够，不够的情况直接原样返回，记得将当前节点置空，此为退出条件~

　　{

　　int t=n；

　　自动cur _ tmp=head

　　while (t 0 cur_tmp！=nullptr)

　　{

　　cur _ tmp=cur _ tmp-next；

　　t-；

　　}

　　如果(t！=0)

　　{

　　cur _ node=nullptr

　　回程头；

　　}

　　}

　　ListNode * pre _ node=nullptr

　　cur _ node=头

　　next _ node=head-next；

　　while (n 0 cur_node！=nullptr)

　　{

　　next _ node=cur _ node-next；

　　cur _ node-next=pre _ node；

　　前节点=当前节点节点；

　　当前节点=下一个节点

　　n-；

　　}

　　head-next=next _ node；

　　返回前节点

　　};

　　自动尾节点=头

　　head=reverse_n(head，k)；

　　while (cur_node！=nullptr)

　　{

　　自动tail _ tmp=cur _ node

　　auto r_list=reverse_n(cur_node，k)；

　　tail _ node-next=r _ list；

　　尾节点=尾节点

　　}

　　回程头；

　　}

　　};

　　ListNode * create _ list(const STD:vector int v)

　　{

　　链表结点头；

　　ListNode * phead=head

　　用于（自动数据：五)

　　{

　　自动节点=新列表节点

　　节点值=数据；

　　node-next=nullptr；

　　phead-next=node；

　　phead=phead-next；

　　}

　　返回头，下一个

　　}

　　int main()

　　{

　　auto list=create _ list(STD:vector int { 1，2，3，4，5 })；

　　auto head=Solution:reverse group(list，2)；

　　而（头！=nullptr)

　　{

　　STD:cout head-val " "；

　　head=head-next；

　　}

　　STD:cout STD:endl；

　　返回0;

　　}

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。