C++链表K个节点K个节点的反转(（1，2，3，4），如果k是2，反转结果是(2,1,4,3))

#include <iostream>
using namespace std;

struct Node
{
int val;
struct Node *next;
Node(int x = int()):val(x),next(NULL){}
};

struct List
{
List()
{
head=NULL;
}
void Insert(int x)
{
if(head==NULL)
{
head = new Node(x);
}
else
{
Node *p = head;
Node *s = new Node(x);
while(p->next!=NULL)
{
p=p->next;
}
p->next = s;
}
}
int Size()
{
Node *p = head;
return Size(p);
}
int Size(Node* p)
{
if(p==NULL)return 0;
return Size(p->next)+1;
}
void Inverted(int a,int b)
{
int i = a-1;
int j = b-1;
int size = Size();
if(size<a || b>size)return ;
Node *p = head->next;
Node *q = head;
Node *prve = NULL;//保存反转节点段前面一个节点.
Node *last = NULL;//保存反转节点段后面一个节点.
if(a==1)
{
while(j)
{
last=p->next;
p->next=q;
q=p;
p=last;
j--;
}
head->next = p;
head = q;
}
else
{
p = head;
q = head;
while(i)
{
prve = p;
p=p->next;
i--;
}
while(j)
{
q=q->next;
j--;
}
last=q->next;
Node *save=NULL;
Node *m = p->next;
Node *n = p;
while(p!=last)
{
save = p->next;
p->next = m;
m=p;
p=save;
}
prve->next=m;
n->next = last;
}
}
void Inverted(int k)
{
Node *p = head;
int i = 1;
int count = 0;
while(p!=NULL)
{
p=p->next;
count++;
}
while(count>0)
{
Inverted(i,i+k-1);
if(count>k)
{
count-=k;
i+=k;
if(count<=k)
continue;
}
if(count<=k)
{
i+=count;
count-=k;
}
}
}
void Show()
{
Node *p = head;
while(p!=NULL)
{
cout<<p->val<<"  ";
p=p->next;
}
cout<<endl;
}

private:
Node *head;
};

int main()
{
int Item;
List list;
while(cin>>Item,Item!=-1)
{
list.Insert(Item);
}//1 2 3 4 5 6 7 8
list.Inverted(2);
list.Show();
return 0;
}

复杂链表的复制思路：

struct Node{

Node *next;

Node *other;//随机指向任意一个其他节点，或者指向NULL。

int val;

};

我们现在原来的链表上，如（1，2，3，4，5），每个节点后面复制一个相同的节点，是（1，1，2，2，3，3，4，4，5，5），然后再将心other的指针指向新的相应节点(偶数节点为新的节点)，再删除奇数节点，就得到了复杂链表的复制。

给大家提供一个学习C++及查询C++的在线网站，相当与一个APP，www.cplusplus.com。