看图深入理解单链表的反转

ActList* ReverseList2(ActList* head)
{
	//ActList* temp=new ActList;
 if(NULL==head|| NULL==head->next) return head; //少于两个节点没有反转的必要。
 ActList* p;
	ActList* q;
	ActList* r;
 p = head; 
 q = head->next;
 head->next = NULL; //旧的头指针是新的尾指针，next需要指向NULL
 while(q){
 r = q->next; //先保留下一个step要处理的指针
 q->next = p; //然后p q交替工作进行反向
 p = q; 
 q = r; 
 }
	head=p; // 最后q必然指向NULL，所以返回了p作为新的头指针
 return head; 
}

struct ListNode{
 int val;
 ListNode* next;
 ListNode(int a):val(a),next(NULL){}
};
ListNode* reverseLinkedList3(ListNode* head){
  if(head==NULL||head->next==NULL)
   return head;
  ListNode* p=head; //指向head
  ListNode* r=head->next; //指向待搬运的节点，即依次指向从第2个节点到最后一个节点的所有节点
  ListNode* m=NULL; //充当搬运工作用的节点
  ListNode* tail=head->next;
  while(r!=NULL){ //bug2 循环语句写错了, while写成了if
   m=r;
   r=r->next;
   m->next=p->next;
   p->next=m;
   //if(r!=NULL)
    //std::cout<<"m="<val<<" ,p="<val<<" ,r="<val<next;
  tail->next=p;
  p->next=NULL;
  tail=p;
  return head; // bug1 忘记了return
 }

ActList* ReverseList3(ActList* head)
{
 ActList* p;
 ActList* q;
 p=head->next;
 while(p->next!=NULL){
 q=p->next;
 p->next=q->next;
 q->next=head->next;
 head->next=q;
 }

 p->next=head;//相当于成环
 head=p->next->next;//新head变为原head的next
 p->next->next=NULL;//断掉环
 return head; 
}

//创建:用q指向当前链表的最后一个节点；用p指向即将插入的新节点。
//反向:用p和q反转工作，r记录链表中剩下的还未反转的部分。

#include "stdafx.h"
#include 
using namespace std;

struct ActList
{
	char ActName[20];
	char Director[20];
	int Mtime;
	ActList *next;
};

ActList* head;

ActList* Create()
{//start of CREATE()
	ActList* p=NULL;
	ActList* q=NULL;
	head=NULL;
	int Time;
	cout<<"Please input the length of the movie."<>Time;
	while(Time!=0){
	p=new ActList;
	//类似表达: TreeNode* node = new TreeNode;//Noice that [new] should be written out.
	p->Mtime=Time;
	cout<<"Please input the name of the movie."<>p->ActName;
	cout<<"Please input the Director of the movie."<>p->Director;

	if(head==NULL)
	{
	head=p;
	}
	else
	{
	q->next=p;
	}
	q=p;
	cout<<"Please input the length of the movie."<>Time;
	}
	if(head!=NULL)
	q->next=NULL;
	return head;

}//end of CREATE()


void DisplayList(ActList* head)
{//start of display
	cout<<"show the list of programs."<next;
	}
}//end of display


ActList* ReverseList2(ActList* head)
{
	//ActList* temp=new ActList;
 if(NULL==head|| NULL==head->next) return head; 
 ActList* p;
	ActList* q;
	ActList* r;
 p = head; 
 q = head->next;
 head->next = NULL;
 while(q){
  r = q->next; //
  q->next = p; 
  p = q; //
  q = r; //
 }
	head=p;
 return head; 
}

ActList* ReverseList3(ActList* head)
{
	ActList* p;
	ActList* q;
	p=head->next;
	while(p->next!=NULL){
		q=p->next;
		p->next=q->next;
		q->next=head->next;
		head->next=q;
	}

	p->next=head;//相当于成环
	head=p->next->next;//新head变为原head的next
	p->next->next=NULL;//断掉环
	return head; 
}
int main(int argc, char* argv[])
{
//	DisplayList(Create());
// DisplayList(ReverseList2(Create()));
	DisplayList(ReverseList3(Create()));
	return 0;
}

// 递归版的第一种实现，借助类的成员变量m_phead来表示新链表的头指针。
struct ListNode{
 int val;
 ListNode* next;
 ListNode(int a):val(a),next(NULL){}
};

class Solution{
  ListNode* reverseLinkedList4(ListNode* head){ //输入: 旧链表的头指针
  if(head==NULL)
   return NULL;
  if(head->next==NULL){
   m_phead=head;
   return head;
  }
  ListNode* new_tail=reverseLinkedList4(head->next);
  new_tail->next=head;
  head->next=NULL;
  return head; //输出: 新链表的尾指针
  }
 ListNode* m_phead=NULL;//member variable defined for reverseLinkedList4(ListNode* head)
};

struct ListNode{
 int val;
 ListNode* next;
 ListNode(int a):val(a),next(NULL){}
};

class Solution{
 ListNode* reverseLinkedList5(ListNode* head, ListNode* & new_head){ //输入参数head为旧链表的头指针。new_head为新链表的头指针。
  if(head==NULL)
   return NULL;
  if(head->next==NULL){
   new_head=head; //当处理到了旧链表的尾指针，也就是新链表的头指针时，对new_head进行赋值。因为是引用型参数，所以在接下来调用中new_head的值逐层传递下去。
   return head;
  }
  ListNode* new_tail=reverseLinkedList5(head->next,new_head);
  new_tail->next=head;
  head->next=NULL;
  return head; //输出参数head为新链表的尾指针。
 }
};