实现链表的反转（递归方法与非递归方法）

链表反转是面试笔试常考题目，直接贴代码。

反转函数如下:

[cpp]  view plain copy

1. //思路为将节点从前到后依次放到表头，最后最后的节点到了最前面,最前面的节点到了最后面  
2. ListNode * ReverseList(ListNode *  head)  
3. {  
4.    //如果链表为空或者链表中只有一个元素  
5.    if(head==NULL || head->m_pNext==NULL)  
6.        return head;  
7.    ListNode * p=head->m_pNext;  
8.    ListNode * q=head;  
9.    while(p!=NULL)  
10.    {  
11.      q->m_pNext=p->m_pNext;//记录下p的下一个节点  
12.      p->m_pNext=head;  
13.      head=p;  
14.      p=q->m_pNext;//准备将p的下一个节点放到表头  
15.    }  
16.    return head;  
17. }  
18.   
19. //递归方式  
20. ListNode * ReverseList2(ListNode * head)  
21. {  
22.     //如果链表为空或者链表中只有一个元素  
23.     if(head==NULL || head->m_pNext==NULL)  
24.         return head;  
25.     else  
26.     {  
27.        ListNode * newhead=ReverseList2(head->m_pNext);//先反转后面的链表  
28.        head->m_pNext->m_pNext=head;//再将当前节点设置为其然来后面节点的后续节点  
29.        head->m_pNext=NULL;  
30.        return newhead;  
31.     }  
32. }  

整体测试代码如下:

[cpp]  view plain copy

1. // 反转链表.cpp : 定义控制台应用程序的入口点。  
2. #include "stdafx.h"  
3. #include  <iostream>  
4. using namespace std;  
5.   
6. //定义一个链表节点  
7.  typedef struct ListNode  
8. {  
9.     int       m_nKey;  
10.     struct ListNode * m_pNext;  
11. }ListNode;  
12.   
13. //插入一个新节点到链表中(放在链表头部)  
14. void CreateList(ListNode * & head,int data)  
15. {  
16.     //创建新节点  
17.     ListNode * p=(ListNode*)malloc(sizeof(ListNode));  
18.     p->m_nKey=data;  
19.     p->m_pNext=NULL;  
20.   
21.     if(head==NULL)  
22.     {  
23.         head=p;  
24.         return;  
25.     }  
26.     p->m_pNext=head;  
27.     head=p;  
28. }  
29.   
30. void  printList(ListNode* head)  
31. {  
32.    ListNode * p=head;  
33.    while(p!=NULL)  
34.    {  
35.       cout<<p->m_nKey<<" ";  
36.       p=p->m_pNext;  
37.    }  
38.    cout<<endl;  
39. }  
40.   
41. //思路为将节点从前到后依次放到表头，最后最后的节点到了最前面,最前面的节点到了最后面  
42. ListNode * ReverseList(ListNode *  head)  
43. {  
44.    //如果链表为空或者链表中只有一个元素  
45.    if(head==NULL || head->m_pNext==NULL)  
46.        return head;  
47.    ListNode * p=head->m_pNext;  
48.    ListNode * q=head;  
49.    while(p!=NULL)  
50.    {  
51.      q->m_pNext=p->m_pNext;//记录下p的下一个节点  
52.      p->m_pNext=head;  
53.      head=p;  
54.      p=q->m_pNext;//准备将p的下一个节点放到表头  
55.    }  
56.    return head;  
57. }  
58.   
59. //递归方式  
60. ListNode * ReverseList2(ListNode * head)  
61. {  
62.     //如果链表为空或者链表中只有一个元素  
63.     if(head==NULL || head->m_pNext==NULL)  
64.         return head;  
65.     else  
66.     {  
67.        ListNode * newhead=ReverseList2(head->m_pNext);//先反转后面的链表  
68.        head->m_pNext->m_pNext=head;//再将当前节点设置为其然来后面节点的后续节点  
69.        head->m_pNext=NULL;  
70.        return newhead;  
71.     }  
72. }  
73.   
74. int _tmain(int argc, _TCHAR* argv[])  
75. {  
76.     ListNode * Head=NULL;  
77.     for(int i=0;i<10;i++)  
78.       CreateList(Head,i);  
79.     printList(Head);  
80.     Head=ReverseList(Head);  
81.     printList(Head);  
82.     system("PAUSE");  
83.     return 0;  
84. }  

运行结果如下: