方法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
第三次循环。。。。。
具体代码如下
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;
}
或者
//链表倒置
public void ReverseList(){
Node p = null;
Node tmp = null;
p = head.next;//p指向当前正在处理的节点
tmp = p.next;//tmp指向尚未被处理的第一个节点
p.next = null;//原单链表第一个节点将成为倒置后最后一个节点
//head.next = p;//插入单链表表头后面
p = tmp;//开始处理接下来的节点们
while (p!=null) {
tmp = p.next;
p.next = head.next;
head.next = p;
p = tmp;
}
}
方法3
从图上观察，方法是：对于一条链表，从第2个节点到第N个节点，依次逐节点插入到第1个节点(head节点)之后，(N-1)次这样的操作结束之后将第1个节点挪到新表的表尾即可。
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;
}
方法4: 递归
现在需要把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指针呢？想到了两个办法。
// 递归版的第一种实现，借助类的成员变量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)
};
//第二个办法是，增加一个引用型参数 new_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为新链表的尾指针。
}
};
本文来自 feliciafay 的CSDN 博客 ，全文地址请点击：blog.csdn.net/feliciafay/…
