1. 解法一（双指针）

ListNode* ReverseList(ListNode* pHead) {
        // 创建双指针，分别指向当前头节点和空指针
        ListNode* pre = pHead, *cur = nullptr;

        // 循环中，当前指针不能为空
        while(pre != nullptr){
            ListNode *new_node = pre->next;    //临时变量，用来存储pre节点的下一个节点
            pre->next = cur;    // 链表反转，将pre的指针指向cur节点
            cur = pre;    //指针+1
            pre = new_node;    // 指针+1
        }
        return cur;    // 返回当前节点，即为反转后的节点
    }

2. 解法二（交换）

 ListNode* ReverseList(ListNode* pHead) {
        ListNode* p = nullptr;
        while(pHead != nullptr){
            swap(pHead->next, p);    // 相当于p临时储存为Phead->next;
            swap(pHead, p);    // 交换head和p，达到反转的目的
        }
        return p;
    }

3. 解法三（递归）

 ListNode* ReverseList(ListNode* pHead) {
        if(head==nullptr || head->next == nullptr) return head;    // 终止条件
        ListNode *p = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return p;
    }

4. 解法四（互换值）

 ListNode* reverseList(ListNode* head) {
        ListNode *p=nullptr;
        for(ListNode* x=head; x!=nullptr; x = x->next){
            p = new ListNode(x->val, p);
        }
        return p;
    }

5. 指定范围内链表反转（迭代）

ListNode* reverseBetween(ListNode* head, int left, int right) {
        // 迭代
        ListNode *dummyNode = new ListNode(-1);
        dummyNode->next = head;
        ListNode* cur = dummyNode;
        // 先走left步
        for(int i=1; i<left; ++i){
            cur = cur->next;
        }

        // 翻转
        head = cur->next;
        for(int i=left; i<right; ++i){
            ListNode* new_node = head->next;
            head->next = new_node->next;
            new_node->next = cur->next;
            cur->next = new_node;
        }
        return dummyNode->next;
    }

6. （递归）