反转链表（递归实现）

反转链表

递归反转整个链表

题目 ：力扣206
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

思路：递归到最后一个节点并返回，然后修改next指针。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
	//设立递归终止条件
	if(head == NULL || head->next == NULL){
		return head;
		}
	//设置反转后的头节点
	ListNode* last = reverseList(head->next);
	//使当前节点的下一个节点指向当前节点
	head->next->next = head;
	//使末尾指向NULL
	head->next = NULL;
	return last;
    }
}; 

反转前n个链表

题目：将链表的前n个节点反转。

思路：和反转整个链表思路一样，只需要注意第n个节点的下一个节点不能为NULL且必须指向第n+1个节点，因此我们只需要设置一个变量记录一下即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
	//设置一个变量记录第n+1个节点
	ListNode* Nnext = NULL;
    ListNode* reverseListN(ListNode* head,int n) {
	//设立递归终止条件
	if(n == 1){
		//设定第n+1个节点
		Nnext = head->next;
		return head;
		}
	//设置反转后的头节点
	ListNode* last = reverseList(head->next,n-1);
	//使当前节点的下一个节点指向当前节点
	head->next->next = head;
	//使末尾指向NULL
	head->next = Nnext;
	return last;
    }
}; 

反转链表的一部分

题目：力扣92
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

例如：
输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]

思路：递归。当left=1,则就变成上面的题目（反转链表的前n个节点），所以递归到left=1即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* Nnext = NULL;    
    ListNode* reverseN(ListNode* head,int n){
        if(n == 1){
        	//记录第n+1个节点
            Nnext = head->next;
            return head;
        }
        ListNode* last = reverseN(head->next,--n);
        head->next->next = head;
        head->next = Nnext;
        return last;
    }
 
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        if(left == 1){
            return reverseN(head,right);
        }
     
        head->next = reverseBetween(head->next,--left,--right);
        return head;

    }
};