单链表递归和非递归两种翻转方法（手写链表）

一.对称翻转的思想

首先最直接的翻转就是对称翻转，以1为对称轴，把后面的数字依次插入最前边形成翻转

---

1    2    3    4    5

2   1   3    4    5

3    2    1    4    5

4    3    2    1    5

5    4    3    2    1

---

Current 指针指向1

pnext   指针指向2

 ptr       指针指向3

以1为对称轴，即用current指针一直指向1，每做一次循环，pnext所指的数字都移动到链表附加头的后面，然后pnext和ptr向右偏移一位（current不变），

每次循环的先决条件是pnext存在（ptr为空表示pnext为链表的最后一位）

那么可以有下面的伪代码

---

（1）初始状态：（初始化）

current一直指向1，//1的地址可以从初始状态时head->next得到；

pnext 等于current所指的下一个节点；

ptr 等于pnext所指的下一个节点；

（2）循环的先决条件是（pnext存在）：

循环内部是：

1.1把current后的元素即pnext插到附加头的后面；

1.2把pnext和ptr都向右移一位（即以current为参考点重新赋值）；

【小技巧】

---

#include<iostream>
using namespace std;
//链表节点结构体
struct LinkNode
{
 int data;
 LinkNode *link;
 LinkNode(LinkNode*p = NULL){ link = p; }
 LinkNode(constint&Item, LinkNode *p = NULL){ data = Item, link = p; }
};
//建立链表
class list
{
public:
 list(){ first = newLinkNode; }
 void input(int); //建立链表节点
 void output();
 void Reversal(); //翻转
 LinkNode*Reversalist(LinkNode*); //翻转(递归)
 LinkNode* getfirstnode();
 
private:
 LinkNode *first, *last;
};
 void list::input(int a)
{
 LinkNode *newnode;
 
 if (NULL==first->link)
 last = first;
 
 newnode = new LinkNode(a);
 if (newnode == NULL)
{
 cerr << "存储分配错误" << endl; exit(1);
}
 last->link = newnode;
 last = newnode;
 
}
void list::output()
{
 LinkNode *outdata =first->link;
 while (outdata)
{
 cout <<outdata->data << endl;
 outdata =outdata->link;
 }
}
//反转链表（非递归）
void list::Reversal()
{
 
 LinkNode *current, *pnext,*ptr;
 current = first->link;
 pnext = current->link;
 //ptr = pnext->link; 应放在循环里，当pnext存在才正确
 while (pnext)
{
 ptr =pnext->link;
 current->link = ptr;
 pnext->link =first->link;
 first->link = pnext;
 pnext = current->link;
}
}
//反转链表（递归）
 LinkNode*list::Reversalist(LinkNode* firstnode)
{
 if (NULL == firstnode ||NULL == firstnode->link)
 return firstnode;
 else
{
 LinkNode* newhead =Reversalist(firstnode->link);
 firstnode->link->link= firstnode; //注意参数
 firstnode->link = NULL;
 
 first->link = newhead;
 return newhead;
}
 
}
 
LinkNode*list::getfirstnode()
{
 return first->link;
}
void main()
{
list testlist;
testlist.input(1);
testlist.input(2);
testlist.input(3);
testlist.input(4);
testlist.input(5);
testlist.input(6);
testlist.input(7);
testlist.output();
 
testlist.Reversal();
cout <<"----------------" << endl;
testlist.output();
cout <<"----------------" << endl;
testlist.Reversalist(testlist.getfirstnode());
testlist.output();
system("pause");
}

---

 

1.递归翻转单链表的算法的总结：

 

LinkNode*list::Reversalist(LinkNode* firstnode)

{

if (NULL == firstnode ||NULL == firstnode->link)

return firstnode;

else

{

LinkNode* newhead =Reversalist(firstnode->link); //-----------------1

firstnode->link->link= firstnode; //重要的翻转操作--2

firstnode->link = NULL;

//first->link =newhead;// ----------------------------3

return newhead;

}

}

(1)首先这种递归方法只关心结点指针

函数的参数中输入的节点指针就是要翻转的单链表的首节点指针，

递归思想：

每次递归要完成的操作是：把当前参数所指向的结点的pnext成员指向上一个结点，修改链表方向，完成链表方向的翻转

---

重要延伸：

 

这种递归翻转可以翻转以任意位置开始的后面的单链表

 

1->2->3->4->5->6->7->8->9->10

 

假如结点 3 的指针是 node3，Reversalist(node3)表示从结点3开始翻转其后的链表，此时

 

1->2->

 

3<-4<-5<-6<-7<-8<-9<-10

Reversalist(node3)返回的值是翻转后的链表的首节点

1->2->此时要指向翻转后的链表的首节点来连成一个完整的链表，标注3就是完成这部操作的。