【leetcode 力扣刷题】反转链表+递归求解

206. 反转链表

题目链接：206.反转链表
题目内容：

理解题意：没有特殊要求，就是把链表反转，相当于从之前的末尾指向开头。

解法①：取下一个节点在当前头节点前插入

第一种方法最容易想到，从前往后遍历链表的同时，每次从原链表中取下当前节点，插入到新链表的开头。 这里的新链表，实际就是该节点之前所有节点已经反转后构成的链表，过程如下：
5

代码如下（C++）：

//依次取出每个节点，并将其插入在新链表的头部
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        //如果链表为空直接返回空指针
        if(!head)
            return nullptr;
        ListNode *currNode = head;
        //初始化新链表，为空
        ListNode *newhead = nullptr;
        while(currNode != nullptr){   
            ListNode *tmp = currNode->next;
            // currNode插入在新链表的头部
            currNode->next = newhead; 
            newhead = currNode;
            //currNode移到下一个节点
            currNode = tmp;         
        }
        //返回新链表
        return newhead;
    }
};  

解法②：反转每个节点next的指向

假设原链表中一前一后两个节点：preNode和currNode，指向是preNode->next = currNode；反转后链表中这俩节点的指向是currNode->next = preNode。既然如此，那么可以在遍历链表中节点的时候【当前节点就用currNode】，直接改变其指针域：

代码如下（C++）：

//遍历链表每个节点，将next改变成指向前面；
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* prev = NULL;  //prev前驱节点初始化为null
        ListNode* currNode = head;  //当前节点初始化为头节点
        while(currNode){
            ListNode* tmp = currNode->next;
            //改变当前节点指针，指向其前驱节点
            currNode->next = prev;
            //prev和currNode都向后移动，遍历链表节点
            prev = currNode;
            currNode = tmp;
        }
        return prev; //最后prev就是新的head，currNode已经为null了
    }
};

本质上解法①和解法②是一样的，只是从两个角度去理解“反转”。

解法③：递归

从前往后遍历链表节点，并使用递归方法的时候，要到最后一个节点才开始往前返回，那么就是先反转后半截链表，再向前返回到当前的节点，再对当前节点处理。假设链表有k个节点：

• 递归到第k个节点的时候，递归终止，并且这最后一个节点就是整个链表反转后的头节点，直接返回该节点地址；
• m+1个节点作为后半截已经反转后的链表的尾节点，其next指向null；现在将m+1和m个节点连接起来，m+1的next指向m；m+1个节点是后半截反转后的尾节点，怎么找到m+1个节点呢？ 【对于当前第m个节点，其next依然指向m+1个节点，因此直接currNode->next->next = currNode，使m+1个节点的next指向当前第m个节点】；
• m现在作为m-1之后剩余链表反转后的尾节点，其next应该指向null；
• 到第m个节点的时候，m+1~k个节点已经反转了，并返回了新的头节点；即便是加上第m个节点并反转，第m个节点也是加在反转后链表的尾部，因此上一步返回的新头节点是整个链表反转后头节点，因此要一直向前返回这个地址；

整个过程如图所示：

代码如下（C++）：

class Solution{
public:
    ListNode* reverseList(ListNode* head) {
    	//如果链表为空，直接返回
    	//如果已经遍历到最后一个节点，最后一个节点就是反转后的头节点，直接返回
        if(head == nullptr || head->next == nullptr)
            return head;
        //当前head之后的链表已经反转了，并返回反转后的新头节点指针     
        ListNode *newhead = reverseList(head->next);
        //将head->next的next指针指向当前head，反转
        head->next->next = head;
        //断开当前head和head->next之间原本的连接
        head->next = nullptr;
        //返回的新头节点是整个链表反转后的头节点，因此一直返回newhead
        return newhead;
    }    
};

92.反转链表Ⅱ

题目链接：92.反转链表Ⅱ
题目内容：

理解题意：在对整个链表反转的基础上，增加了限制条件——只反转给定的left~right位置间的节点。 完成left~right的反转后，还需要让left之前的节点left_pre->next指向right；还需要让left->next指向right->next。
以下解法为一遍访问链表完成left~right之间的节点的反转：

反转left到right间节点的next指向

整个过程分为以下几步：

• 需要记录的节点有left、right、left前面一个节点left_pre和right后面一个节点right->next；
• 先遍历链表找到left_pre和left；
• 从left开始到right，用反转链表题目的解法，反转这一段链表；用到pre和currNode两个变量保存当前要改变指向的节点、以及之前的一个节点；
• 上一步循环结束时，pre就是right，currNode就是right->next； 此时建立新连接：left_pre->next = right【即pre】，left->next = right->next【即currNode】； 得到完整链表；

上述过程为一次遍历链表，在遍历的过程中改变left~right间的指向。全部代码如下（C++）：

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
    	//如果left和right相等，没有节点要反向
        if(left == right) 
        	return head;
        //存left和left前面一个节点的地址
        ListNode *leftNode = head, *left_prev = NULL;
        //定位到leftNode，并保存left_pre
        for(int i=1; i<left && leftNode; i++ ){
            left_prev = leftNode;
            leftNode = leftNode->next;
        } 
        //left~right间反向时用到的变量  
        ListNode *prev, *currNode;   //当前节点和当前节点的前一个节点    
        prev = leftNode;
        currNode = prev->next;
        while(currNode && left < right){
            ListNode* tmp = currNode->next;
            //反转next指向
            currNode->next = prev;
            //pre和currNode都向前移动，遍历left~right间节点
            prev = currNode;
            currNode = tmp;
            left++;
        }  //循环结束后pre是right节点，currNode是right->next节点
        //左边节点leftNode指向right->next
        leftNode->next = currNode;
        //判断leftnode是不是头节点
        if(left_prev  != NULL) //如果不是，left前面一个节点指向right节点
            left_prev->next = prev;
        else //如果是，新的头节点就是right节点
            head =  prev;        
        return head;
    }
};

234.回文链表

题目链接：203.回文链表
题目内容：

理解题意：实际就是判断是不是回文【回文数：从前往后、从后往前是一样的，比如0123210；判断：两个指针一个开头，一个结尾，逐个对比，全相等就是回文】，只是换成了在链表上判断。 但是由于链表只能向next一个方向遍历，不像数组、string等可以用下标index去定位。因此有两种解法：

• 遍历链表，并且把链表各个节点的val按照顺序存在vector里面，然后在vector上比较；
• 直接在链表上比较；

直接在链表上进行比较又有两种方法：

• 遍历链表的同时，用上面的反转链表方法，把前半部分链表反转；反转后的前半部分链表和后半部分链表的节点逐个对比，val值都一样即为回文；
• 递归求解：因为递归到最后一个节点才递归终止，能够知道当前的节点的val；一开始的head还在开头，就能实现首尾比较；一旦不相等，其他节点就不用比较了，直接向前返回false；如果相等，后面的节点向前返回到前面一个节点进行操作，前面节点需要向后移动；

解法①：将链表元素存在数组中，在数组上判断回文

这个方法最好理解，也没有什么难度，先遍历链表取出各个节点的val，按原顺序存在vector中，在vector上实现回文判断，需要额外的空间……
代码如下（C++）：

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        vector<int> val;  //数组用于存储链表节点的val
        ListNode *currNode = head;
        //遍历链表节点，并保存各个节点的val
        while(currNode){
            val.emplace_back(currNode->val);
            currNode = currNode->next;
        }
        //双指针，判断数组是否是回文的
        for(int i = 0, j = val.size() - 1; i < j ; i++,j--){
      		//一旦有节点不相等，就不是回文
            if(val[i] != val[j])
                return false;
        }
        return true;
    }
 };

解法②：在链表上反转前半部分链表，和后半部分对比

这个方法是一次遍历链表，遍历的过程中，同时反转链表，这个反转结束的地方是链表的中间点； 从这个中间点开始，用一个指针逐个向前访问前面一段链表的节点，再用一个指针逐个向后访问后面一段链表的节点；并比较节点的val，判断是否是回文，过程如下所示：

这里有个问题，就是如何找到链表的中间节点：用一个slow指针，一个fast指针，初始slow和fast都为head【没有附加头结点时】，每次slow向后移动一个slow = slow->next，但是fast向后移动两个fast = fast->next->next。当fast->next =null的时候【有偶数个节点】或fast->next->next = null的时候【有奇数个节点】终止，此时的slow就定位在中间节点。
代码实现（C++）：

class Solution {
public:
    bool isPalindrome(ListNode* head) {
    	//如果只有一个节点直接返回true
        if(head->next== nullptr)
            return true;
        //用slow、fast来寻找链表的中间点，prev是slow前面一个节点，辅助完成反转操作       
        ListNode *slow = head,*fast = head, *prev = NULL;
        //找到中间节点，并同时反转前半段链表
        while(fast->next && fast->next->next){  
            fast = fast->next->next;       
            ListNode* tmp = slow->next;
            slow->next = prev;
            prev = slow;
            slow = tmp;                       
        } 
        //上述循环结束时，slow是(n+1)/2节点
        //比如5个节点，slow在第3个节点；6个节点，slow在第3个节点
        //且此时slow指向是原始的指向
        ListNode *right_head, *left_head; //左右两段一段向前，一段向后链表的头节点
        right_head = slow->next;  //右边头节点就是slow->next
        //偶数个节点，slow需要反转连接
        if(fast->next){            
            slow->next = prev;
            left_head = slow;
        }
        //奇数个节点，slow不需要反转连接
        else{ 
            left_head = prev;  
        }
        //两段链表节点逐个对比val
        while(left_head!=nullptr && right_head!=nullptr){
            if(left_head->val != right_head->val)
                return false;
            left_head = left_head->next;
            right_head = right_head->next;
        }
        return true;
    }
};

其中奇数个节点、偶数个节点需要分开讨论，写代码的时候要区分开。

解法③：递归

这里的递归求解参考的力扣官方题解。因为递归到最后一个节点才递归终止，能够知道当前的节点的val；一开始的frontNode还在开头，就能实现首尾比较；一旦不相等，其他节点就不用比较了，直接向前返回false；如果相等，后面的节点向前返回到前面一个节点进行操作，前面节点需要向后移动；
递归的时候需要一个指针，递归到最后向前返回；那么还需要一个外部指针，递归返回后，它向后移动。
代码实现（C++）：

class Solution {
public:
    ListNode* frontNode; //需要定义一个全局的变量
    bool recursivelyCheck(ListNode *currNode){
        if(currNode){
            //后面已经有节点和前面的不相等，中间一截不用比较了直接向上返回false
            if(!recursivelyCheck(currNode->next))
                return false;
            //对比当前元素与前面对应元素是否一样
            if(currNode->val != frontNode->val)
                return false;
            //将前面元素向后面移动一个
            frontNode = frontNode->next;
        }
        return true;
    }
    bool isPalindrome(ListNode* head) {
        frontNode = head; 
        return recursivelyCheck(head);
    }
};