单链表反转递归与非递归算法

1. 代码如下：

View Code

  1 #include <iostream>
  2 #include <cassert>
  3 
  4 using namespace std;
  5 
  6 struct Node 
  7 {
  8     Node* m_next;
  9     int m_data;
 10     Node(int data=0,Node* next=NULL)
 11     {
 12         this->m_data=data;
 13         this->m_next=next;
 14     }
 15 };
 16 
 17 Node* CreateList(int *elem, int length)
 18 {
 19     assert(elem && length>0);
 20     Node* p=new Node(*(elem+length-1),NULL);
 21     for (int i=length-2;i>=0;i--)
 22     {
 23         p=new Node(*(elem+i),p);
 24     }
 25     return p;
 26 }
 27 
 28 void DestroyList(Node* &p)
 29 {
 30     if (!p)
 31     {
 32         return ;
 33     }
 34     Node* tmp=p;
 35     while(p)
 36     {
 37         tmp=p;
 38         p=p->m_next;
 39         delete tmp;
 40     }
 41 }
 42 
 43 void print(Node* p)
 44 {
 45     if (!p)
 46     {
 47         return ;
 48     }
 49     while(p)
 50     {
 51         cout<<p->m_data<<"  ";
 52         p=p->m_next;
 53     }
 54     cout<<endl;
 55 }
 56 void IterativeReverse(Node* &p)
 57 {
 58     if (!p)
 59     {
 60         return ;
 61     }
 62     Node* pre=NULL;
 63     Node* curr=p;
 64     while (curr)
 65     {
 66         Node* next=curr->m_next;
 67         curr->m_next=pre;
 68         pre=curr;
 69         curr=next;
 70     }
 71     p=pre;
 72 }
 73 
 74 void RecursiveReverse(Node* &p)
 75 {
 76     if (!p)
 77     {
 78         return ;
 79     }
 80     Node* rest=p->m_next;
 81     if (!rest)
 82     {
 83         return ;
 84     }
 85     RecursiveReverse(rest);
 86     p->m_next->m_next=p;
 87     p->m_next=NULL;
 88     p=rest;
 89 }
 90 
 91 int main()
 92 {
 93     enum {length=8};
 94     int elem[length]={23,43,12,0,14,1,17,9};
 95     Node* pList=CreateList(elem,length);
 96     print(pList);
 97     //IterativeReverse(pList);
 98     RecursiveReverse(pList);
 99     print(pList);
100     DestroyList(pList);
101     return 0;
102 }

2. 在非递归算法（迭代算法）中，需要注意的是边界条件检查问题，这里巧妙地只检查curr是否为空，初始情况下将pre设置为NULL，在curr不为空的情况下定义next指针，之后迭代逐次向后修改链表中的指针。

3. 在递归算法中，最后一句p=rest保证rest一直指向反转链表的头部，不会改变，还没理解这个究竟是怎样做到的。

参考文章：

http://www.leetcode.com/2010/04/reversing-linked-list-iteratively-and.html#comment-23502

转载于:https://www.cnblogs.com/ZJUKasuosuo/archive/2012/08/08/2628917.html