剑指offer - 15反转链表

输入一个链表，反转链表后，输出新链表的表头。

思路有下面三种：

1. 各节点相对位置不变的情况下 改变next指针的方向 反转list

2. 创建一个头节点，遍历链表，每个节点都插入到新头结点的next

3. 递归方法

代码如下：

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    //方法一：各节点相对位置不变的情况下 改变next指针的方向 反转list
    ListNode* reverse_list(ListNode* head){
        if(NULL == head){
            return NULL;
        }
        ListNode* t = NULL;
        ListNode* p = head;
        ListNode* q = head->next;
        while(NULL != q){
            t = q->next;
            q->next = p;
            p = q;
            q = t;
        }
        // 循环结束后p为翻转后的头结点 head为尾节点
        head->next = NULL;
        return p;
    }
    // 方法二：申请一个新的头结点 遍历链表 依次插入到新头结点之后
    //        也就是创建了一个带头结点的新链表，依次在链表的头部依次插入新节点 
    ListNode* reverse_list_by_insert(ListNode* head){
        ListNode* newhead = new ListNode(-1);
        ListNode* p = head;
        while(p){
            ListNode* t = p->next;
            p->next = newhead->next;
            newhead->next = p;
            p = t;
        }
        head = newhead->next;
        delete newhead;
        return head;
    }
    
    // 方法三：递归方法
    ListNode* reverse_recursion(ListNode* node){
        if(NULL == node || NULL == node->next){
            return node;
        }
        ListNode* reverselist = reverse_recursion(node->next); //这里的返回值是next链表的头结点，也就是反转之前的尾节点
        node->next->next = node;  // node是当前节点  node->next是已反转链表的尾节点
        node->next = NULL;
        return reverselist;
    }

    ListNode* ReverseList(ListNode* pHead) {
        //return reverse_list(pHead);
        //return reverse_list_by_insert(pHead);
        return reverse_recursion(pHead);
    }
};