方法一：使用栈，注意，在每次出栈将指针指向出栈的元素，然后将指针指向自己的next之后，一定要注意再将指针的next为NULL,否则会报错。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode * hd = new ListNode;
        stack<ListNode*> array;
        while(head!=nullptr)
        {
            array.push(head);
            head = head ->next;

        }
        ListNode * temp1 = hd;
        while(!array.empty())
        {
            hd->next = array.top();
            array.pop();
            hd = hd->next;
            hd->next = nullptr;
            
        }
        return temp1->next;

    }
};

方法二：

迭代，简单思想就是，初始化两个指针，一个指向头节点，一个指向null，也即一个在前一个在后，然后每次先存一下前面结点的next，然后把后面结点的值给前面结点的next，然后将前面结点的位置传给后面结点（向后移动），然后把刚刚存下的前面结点的next传给前面结点（向后移动）

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *pre = head;
        ListNode *cur = nullptr;
        while(pre)
        {
            ListNode *temp = pre->next;
            pre->next = cur;
            cur = pre;
            pre = temp;
        }
        return cur;

    }
};

方法三：递归

递归版本稍微复杂一些，其关键在于反向工作。假设链表的其余部分已经被反转，现在应该如何反转它前面的部分？

答：让k+1的next指向k，操作就是k=k->next->next，并且应让k->next指向null，佛祖额链表中可能会产生环。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(!head||!head->next)
            return head;
        ListNode *NewHead = reverseList(head->next);
        head->next->next = head;
        head->next=nullptr;
    return NewHead;
    }
};