c++ leetcode---结题报告79.反转链表

第一种做法：用栈来做，不过根本情况要搞清楚，就是头结点的是否存在问题，
如果这道题头结点存在（只有指针没数据），那么要先curr = curr->next,再number = curr->val;
否则要先number = curr->val;在curr = curr->next；

第二种做法，递归
递归，第一部找边界： if(head == NULL || head->next == NULL) return head;找到头节点
第二部递归：首先我们需要一直递归到终点，那么递归条件是head = reverseList(head->next)

第二reverseList(head->next)这个返回的是一个已经倒排好的链表（元素少一个），那么我们只需要把以前的头节点当作最后一个节点链接进去就行了。
之前的头结点已经不在里面了，也就是说假设原来的头节点是a[0]，头结点的next是a[1]，那么a[1]已经是reverseList(head->next)这个返回队列的最后一个结点，但是
head->next还是a[1]，所以在n个结点的层面来说 head->next->next = head;head->next = NULL;
递归的根本思想还是：1.当n=1时正确，2.已知对n=k-1成立，想办法写出代码解决n=k的问题。
引用一个博客的说法：这个博客的递归讲的特别好：https://blog.csdn.net/vagrxie/article/details/8470798
1.你必须要示范如何解决问题的一般情况, 通过将问题切分成有限小并更小的子问题.
2.你必须要示范如何通过有限的步骤, 来解决最小的问题(基本用例).
如果这两件事完成了, 那问题就解决了. 因为递归每次都将问题变得更小, 而一个有限的问题终究会被解决的, 而最小的问题仅需几个有限的步骤就能解决.

第一种方法的代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* curr = head;
        stack<int> intsave;
        int number = 0;
        while(curr!=NULL)
        {
                number = curr->val;
                intsave.push(number);
                curr = curr->next;

          }
        curr = head;
        while(curr!=NULL)
        {
            number = intsave.top();
            intsave.pop();
            curr->val = number;
            curr = curr->next;

        }
        return head;
    }
};

第二种方法递归代码：：

class Solution {
public:
        ListNode* reverseList(ListNode* head) {
        if(head == NULL || head->next == NULL) return head;
        ListNode* curr = head;
        head = reverseList(head->next);
        curr->next->next = curr;
        curr->next = NULL;
        return head;


    }
};