码迷，mamicode.com
首页 > 其他好文 > 详细

看图理解单链表的反转

时间：2017-07-11 13:25:21      阅读：156      评论：0      收藏：0      [点我收藏+]

标签：需要   isp   代码   []   argv   int   插入   process   type   

如何把一个单链表进行反转？

方法1：将单链表储存为数组，然后按照数组的索引逆序进行反转。

方法2：使用3个指针遍历单链表，逐个链接点进行反转。

方法3：从第2个节点到第N个节点，依次逐节点插入到第1个节点(head节点)之后，最后将第一个节点挪到新表的表尾。

方法4:   递归(相信我们都熟悉的一点是，对于树的大部分问题，基本可以考虑用递归来解决。但是我们不太熟悉的一点是，对于单链表的一些问题，也可以使用递归。可以认为单链表是一颗永远只有左(右)子树的树，因此可以考虑用递归来解决。或者说，因为单链表本身的结构也有自相似的特点，所以可以考虑用递归来解决)

 

方法1：

浪费空间。

 

 

方法2:

使用p和q两个指针配合工作，使得两个节点间的指向反向，同时用r记录剩下的链表。

 

p = head;

q = head->next;

技术分享

 

head->next = NULL;

技术分享

 

现在进入循环体，这是第一次循环。

r = q->next;

q->next = p;

技术分享

 

p = q;

q =r;

技术分享

 

第二次循环。

r = q->next

技术分享

 

q->next = p;    

技术分享

 

p = q;

技术分享

 

q = r

技术分享

第三次循环。。。。。

 

 

具体代码如下

 

[cpp] view plain copy
 print?
  1. ActList* ReverseList2(ActList* head)  
  2. {  
  3.     //ActList* temp=new ActList;  
  4.  if(NULL==head|| NULL==head->next) return head;    //少于两个节点没有反转的必要。  
  5.     ActList* p;  
  6.     ActList* q;  
  7.     ActList* r;  
  8.     p = head;    
  9.     q = head->next;  
  10.     head->next = NULL; //旧的头指针是新的尾指针，next需要指向NULL  
  11.     while(q){  
  12.         r = q->next; //先保留下一个step要处理的指针  
  13.         q->next = p; //然后p q交替工作进行反向  
  14.         p = q;   
  15.         q = r;   
  16.     }  
  17.     head=p; // 最后q必然指向NULL，所以返回了p作为新的头指针  
  18.     return head;      
  19. }  

 

updated 2014-01-24，重新非IDE环境写了一遍
如果觉得上面的先成环再断环的过程不太好理解，那么可以考虑下面这个办法，增加一个中间变量，使用三个变量来实现。

[cpp] view plain copy
 print?
  1. struct ListNode{  
  2.     int val;  
  3.     ListNode* next;  
  4.     ListNode(int a):val(a),next(NULL){}  
  5. };  
  6. ListNode* reverseLinkedList3(ListNode* head){  
  7.         if(head==NULL||head->next==NULL)  
  8.             return  head;  
  9.         ListNode* p=head; //指向head  
  10.         ListNode* r=head->next; //指向待搬运的节点，即依次指向从第2个节点到最后一个节点的所有节点  
  11.         ListNode* m=NULL; //充当搬运工作用的节点  
  12.         ListNode* tail=head->next;  
  13.         while(r!=NULL){  //bug2 循环语句写错了, while写成了if  
  14.             m=r;  
  15.             r=r->next;  
  16.             m->next=p->next;  
  17.             p->next=m;  
  18.             //if(r!=NULL)  
  19.                 //std::cout<<"m="<<m->val<<" ,p="<<p->val<<" ,r="<<r->val<<std::endl;  
  20.             //else  
  21.                 //std::cout<<"m="<<m->val<<" ,p="<<p->val<<" ,r=NULL"<<std::endl;  
  22.         }  
  23.         head=p->next;  
  24.         tail->next=p;  
  25.         p->next=NULL;  
  26.         tail=p;  
  27.         return head; // bug1 忘记了return  
  28.     }  



 

 

方法3

还是先看图，

技术分享

从图上观察，方法是：对于一条链表，从第2个节点到第N个节点，依次逐节点插入到第1个节点(head节点)之后，(N-1)次这样的操作结束之后将第1个节点挪到新表的表尾即可。

代码如下:

 

[cpp] view plain copy
 print?
  1. ActList* ReverseList3(ActList* head)  
  2. {  
  3.     ActList* p;  
  4.     ActList* q;  
  5.     p=head->next;  
  6.     while(p->next!=NULL){  
  7.         q=p->next;  
  8.         p->next=q->next;  
  9.         q->next=head->next;  
  10.         head->next=q;  
  11.     }  
  12.   
  13.     p->next=head;//相当于成环  
  14.     head=p->next->next;//新head变为原head的next  
  15.     p->next->next=NULL;//断掉环  
  16.     return head;    
  17. }  

 

 

附:

完整的链表创建，显示，反转代码:

 

[cpp] view plain copy
 print?
  1. //创建:用q指向当前链表的最后一个节点；用p指向即将插入的新节点。  
  2. //反向:用p和q反转工作，r记录链表中剩下的还未反转的部分。  
  3.   
  4. #include "stdafx.h"  
  5. #include <iostream>  
  6. using namespace std;  
  7.   
  8. struct ActList  
  9. {  
  10.     char ActName[20];  
  11.     char Director[20];  
  12.     int Mtime;  
  13.     ActList *next;  
  14. };  
  15.   
  16. ActList* head;  
  17.   
  18. ActList*  Create()  
  19. {//start of CREATE()  
  20.     ActList* p=NULL;  
  21.     ActList* q=NULL;  
  22.     head=NULL;  
  23.     int Time;  
  24.     cout<<"Please input the length of the movie."<<endl;  
  25.     cin>>Time;  
  26.     while(Time!=0){  
  27.     p=new ActList;  
  28.     //类似表达:  TreeNode* node = new TreeNode;//Noice that [new] should be written out.  
  29.     p->Mtime=Time;  
  30.     cout<<"Please input the name of the movie."<<endl;  
  31.     cin>>p->ActName;  
  32.     cout<<"Please input the Director of the movie."<<endl;  
  33.     cin>>p->Director;  
  34.   
  35.     if(head==NULL)  
  36.     {  
  37.     head=p;  
  38.     }  
  39.     else  
  40.     {  
  41.     q->next=p;  
  42.     }  
  43.     q=p;  
  44.     cout<<"Please input the length of the movie."<<endl;  
  45.     cin>>Time;  
  46.     }  
  47.     if(head!=NULL)  
  48.     q->next=NULL;  
  49.     return head;  
  50.   
  51. }//end of CREATE()  
  52.   
  53.   
  54. void DisplayList(ActList* head)  
  55. {//start of display  
  56.     cout<<"show the list of programs."<<endl;  
  57.     while(head!=NULL)  
  58.     {  
  59.         cout<<head->Mtime<<"\t"<<head->ActName<<"\t"<<head->Director<<"\t"<<endl;  
  60.         head=head->next;  
  61.     }  
  62. }//end of display  
  63.   
  64.   
  65. ActList* ReverseList2(ActList* head)  
  66. {  
  67.     //ActList* temp=new ActList;  
  68.  if(NULL==head|| NULL==head->next) return head;      
  69.     ActList* p;  
  70.     ActList* q;  
  71.     ActList* r;  
  72.     p = head;    
  73.     q = head->next;  
  74.     head->next = NULL;  
  75.     while(q){  
  76.         r = q->next; //  
  77.         q->next = p;      
  78.         p = q; //  
  79.         q = r; //  
  80.     }  
  81.     head=p;  
  82.     return head;      
  83. }  
  84.   
  85. ActList* ReverseList3(ActList* head)  
  86. {  
  87.     ActList* p;  
  88.     ActList* q;  
  89.     p=head->next;  
  90.     while(p->next!=NULL){  
  91.         q=p->next;  
  92.         p->next=q->next;  
  93.         q->next=head->next;  
  94.         head->next=q;  
  95.     }  
  96.   
  97.     p->next=head;//相当于成环  
  98.     head=p->next->next;//新head变为原head的next  
  99.     p->next->next=NULL;//断掉环  
  100.     return head;    
  101. }  
  102. int main(int argc, char* argv[])  
  103. {  
  104. //  DisplayList(Create());  
  105. //  DisplayList(ReverseList2(Create()));  
  106.     DisplayList(ReverseList3(Create()));  
  107.     return 0;  
  108. }  

 

方法4:  递归

updated: 2014-01-24

因为发现大部分问题都可以从递归角度想想，所以这道题目也从递归角度想了想。

现在需要把A->B->C->D进行反转，
可以先假设B->C->D已经反转好，已经成为了D->C->B,那么接下来要做的事情就是将D->C->B看成一个整体，让这个整体的next指向A，所以问题转化了反转B->C->D。那么，
可以先假设C->D已经反转好，已经成为了D->C,那么接下来要做的事情就是将D->C看成一个整体，让这个整体的next指向B，所以问题转化了反转C->D。那么，
可以先假设D(其实是D->NULL)已经反转好，已经成为了D(其实是head->D),那么接下来要做的事情就是将D(其实是head->D)看成一个整体，让这个整体的next指向C，所以问题转化了反转D。
上面这个过程就是递归的过程，这其中最麻烦的问题是，如果保留新链表的head指针呢？想到了两个办法。

 

[cpp] view plain copy
 print?
  1. // 递归版的第一种实现，借助类的成员变量m_phead来表示新链表的头指针。  
  2. struct ListNode{  
  3.     int val;  
  4.     ListNode* next;  
  5.     ListNode(int a):val(a),next(NULL){}  
  6. };  
  7.   
  8. class Solution{  
  9.      ListNode* reverseLinkedList4(ListNode* head){ //输入: 旧链表的头指针  
  10.         if(head==NULL)  
  11.             return NULL;  
  12.         if(head->next==NULL){  
  13.             m_phead=head;  
  14.             return head;  
  15.         }  
  16.         ListNode* new_tail=reverseLinkedList4(head->next);  
  17.         new_tail->next=head;  
  18.         head->next=NULL;  
  19.         return head; //输出: 新链表的尾指针  
  20.      }  
  21.     ListNode* m_phead=NULL;//member variable defined for reverseLinkedList4(ListNode* head)  
  22. };  

 

 

第二个办法是，增加一个引用型参数 new_head，它用来保存新链表的头指针。

 

[cpp] view plain copy
 print?
    1. struct ListNode{  
    2.     int val;  
    3.     ListNode* next;  
    4.     ListNode(int a):val(a),next(NULL){}  
    5. };  
    6.   
    7. class Solution{  
    8.     ListNode* reverseLinkedList5(ListNode* head, ListNode* & new_head){ //输入参数head为旧链表的头指针。new_head为新链表的头指针。  
    9.         if(head==NULL)  
    10.             return NULL;  
    11.         if(head->next==NULL){  
    12.             new_head=head; //当处理到了旧链表的尾指针，也就是新链表的头指针时，对new_head进行赋值。因为是引用型参数，所以在接下来调用中new_head的值逐层传递下去。  
    13.             return head;  
    14.         }  
    15.         ListNode* new_tail=reverseLinkedList5(head->next,new_head);  
    16.         new_tail->next=head;  
    17.         head->next=NULL;  
    18.         return head; //输出参数head为新链表的尾指针。  
    19.     }  
    20. };  

看图理解单链表的反转

标签：需要   isp   代码   []   argv   int   插入   process   type   

原文地址：http://www.cnblogs.com/mafeng/p/7149980.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！