234. Palindrome Linked List

参考：labuladong

问题：

判断一个链表，是否为回文链表。

Example 1:
Input: 1->2
Output: false

Example 2:
Input: 1->2->2->1
Output: true

　　

解法：

解法一：Linked List Traverse 链表遍历（后序遍历）

pre_traverse(ListNode* head){
    printf(head->val);//前序遍历
    pre_traverse(head->next);
}

post_traverse(ListNode* head){
    post_traverse(head->next);
    printf(head->val);//后序遍历
}

先递归到链表结尾，访问结尾节点

再往回依次遍历当前节点的前一个节点。

本问题中，

我们要判断回文序列，即判断首尾两边，向中间夹逼，依次相等即可。

因此，要利用链表后序遍历，

首先找到结尾节点right

与首节点left进行比较。

因此这里的left需要，

在递归底部开始回退弹栈的过程中，顺序遍历left=left->next

所以，我们令left作为外部全局变量，不随函数弹栈改变。

递归函数中要传递的信息：res

当前right和left的比较结果&&上次弹栈前的二者比较结果res

即：

res=(left->val==right->val)&&res

代码参考：

/**
 * 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* left;
    bool isPalindrome(ListNode* head) {
        left = head;
        return traverse(head);
    }
    bool traverse(ListNode* right) {
        bool res;
        if(!right) return true;
        res = traverse(right->next);
        //post traverse
        res = (left->val==right->val && res);
        left = left->next;
        return res;
    }
};

解法二：Linked List Reverse 链表反转

首先使用快慢指针的方法，找到链表中间节点mid

（slow一次走一步，fast一次走两步）

这里⚠️ 注意，

• 若链表有奇数个节点：fast!=null, fast->next==null
  • 　　这时，需要对比除去中间这一个节点之外，从中间到两边对比。
• 若链表有偶数个节点：fast==null，fast->next更不可能存在
  • 　　这时，刚好slow所在节点为，链表节点对半分后，右边第一个节点。

然后，反转slow->链表结尾tail，返回反转后的头节点tail

从head和tail开始比对，依次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:
    bool isPalindrome(ListNode* head) {
        if(!head) return true;
        ListNode* mid = findmid(head);
        ListNode* left = head;
        ListNode* right = reverse(mid);
        while(right){
            if(left->val != right->val) {
                return false;
            }
            left = left->next;
            right = right->next;
        }
        return true;
    }
    ListNode* reverse(ListNode* a) {
        ListNode* cur = a, *pre = nullptr;
        while(cur) {
            ListNode* nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }
    ListNode* findmid(ListNode* head) {
        ListNode* slow, *fast;
        slow = head;
        fast = head;
        while(fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        if(fast) {//odd:1,3,5,7... nodes
            return slow->next;
        } else {
            return slow;
        }
    }
};