单向链表每k个数逆序拼接

问题：

有一个单链表，请设计一个算法，使得每K个节点之间逆序，如果最后不够K个节点一组，则不调整最后几个节点。例如链表1->2->3->4->5->6->7->8->null，K=3这个例子。调整后为，3->2->1->6->5->4->7->8->null。因为K==3，所以每三个节点之间逆序，但其中的7，8不调整，因为只有两个节点不够一组。

给定一个单链表的头指针head,同时给定K值，返回逆序后的链表的头指针。

解决方法：

/*

struct ListNode {

int val;

struct ListNode *next;

ListNode(int x) : val(x), next(NULL) {}

};*/

class KInverse {

public:

void reverse(ListNode *head,int k) //k个数逆序

{

if(head==NULL)return;

ListNode *pos=head;

vector<int>stack;

while(pos!=NULL&&stack.size()<k)

{

stack.push_back(pos->val);

pos=pos->next;

}

if(stack.size()<k)return;

pos=head;

while(!stack.empty())

{

pos->val=stack.back();

stack.pop_back();

pos=pos->next;

}

}

ListNode * NextK(ListNode *start,int k) //获取下k个数的起点

{

if(start==NULL)return NULL;

while(k>0&&start!=NULL)

{

start=start->next;

k--;

}

return start;

}

ListNode* inverse(ListNode* head, int k) {

// write code here

if(head==NULL)return NULL;

ListNode *pos=head;

while(pos!=NULL)

{

reverse(pos,k);

pos=NextK(pos,k);

}

return head;

}

};

我下面写的方法就一直报：输出超限:您的程序打印了太多的内容

ListNode* inverse(ListNode* head, int k) {

// write code here

int num=0;

ListNode * tmp=head;

while(tmp)

{

num++;

tmp=tmp->next;

}

if(num<k)return head;

tmp=head;

ListNode *ret; //返回的头结点

ListNode *last; //k个数整数倍剩余的项

int nLast=num-(num/k)*k;

int m=0;

if(nLast==0)last=NULL;

else

{

while(tmp)

{

m++;

if(m>(num/k)*k)

{

last=tmp;

break;

}

tmp=tmp->next;

}

}

tmp=head;

ListNode *ss=head;

for(int i=0;i<num/k;i++) //num/k轮逆序

{

ListNode *t;

if(i==0)tmp=head;

else tmp=ss;

for(int s=k-1;s>0;s--) //获取每一轮第k个数,然后从后往前依次改变指向

{

int p=1;

while(p<s)

{

tmp=tmp->next;

p++;

}

if(i==0&&s==k-1)ret=tmp->next;

if(s==k-1)

{

t=tmp->next; //每轮逆序的头结点

ss=tmp->next->next; //下轮逆序的起点

}

tmp->next->next=tmp; //改变链表的指向

}

if(i>0)

{

tmp=ret;

int count=i*k;

int kk=0;

while(kk<count)

{

tmp=tmp->next;

kk++;

}

tmp->next=t; //连接每轮逆序之后的链表

}

}

return ret;

}

大神帮忙看下第二种解法问题在哪？