进步感受：

well done～～！，又是自己做出这道题目了，没有一点提示，经过不断的锻炼大脑好像慢慢被活化了，灵感崩发，让我想到了链表平分+翻转对比，来实现判断是否为回文！

解题思路：

官方的解题思路跟我的是一样的，都是平分链表+翻转比较，但是，官方是从后面翻转，我则是从前面翻转，导致我要考虑链表奇数偶数个的情况。

具体实现步骤：

1，使用快慢指针，平分两个链表；

2、从中点slow指针，开始翻转链表，之后比较是否相等，从而判断是否是回文结构；

3、有一点要注意的是，翻转的时候，其实会断开head的链表的。

// 思路把链表平分成两段，之后对前半段翻转，之后就可以比较了

// 把链表平分的方法，一种是得到长度后再计算，平分，另一种则是用快慢指针，直接平分更快

// 就类似单链表排序的问题，可以用left/mid/right对链表进行拆分，right为空说明偶数，否则是奇数

import java.util.*;

public class Solution {

    /**
     * 官方的解法，跟我的解法是一样的，
     * 平分链表后，反转一半，但是我是从左边翻转，
     * 导致，要考虑奇偶数个的情况。
     */
    public boolean isPail (ListNode head) {
        if(head==null) {
            return false;
        }
        ListNode fast = head;
        ListNode slow = head;

        while(fast!=null && fast.next!=null) {
            slow = slow.next;
            fast = fast.next.next;
        }

        // 这里有意思，
        // slow后面的链表翻转的同时
        // 第一次翻转时，prev==null
        // 会导致head链表断开到slow节点
        // 而反转列表从slow节点开始
        // 举个例子head={1,2,2,2,1}，反转后
        // head={1,2,2}, slow={1,2,2} 
        slow = reverseListNode(slow);
        fast = head;
        while(slow != null) {
            if(slow.val != fast.val) {
                return false;
            }
            fast = fast.next;
            slow = slow.next;
        }

        return true;
    }


    /**
     * 我的解法
     * @param head ListNode类 the head
     * @return bool布尔型
     */
     // 思路把链表平分成两段，之后对前半段翻转，之后就可以比较了
     // 把链表平分的方法，一种是得到长度后再计算，平分，另一种则是用快慢指针，直接平分更快
     // 就类似单链表排序的问题，可以用left/mid/right对链表进行拆分，right为空说明偶数，否则是奇数
    public boolean isPail2 (ListNode head) {
        if(head== null) {
            return false;
        }
        if(head.next==null) {
            return true;
        }

        ListNode left = head;
        ListNode mid = head.next;
        ListNode right = head.next.next;

        while(right!=null && right.next!=null) {
            left = left.next;
            mid = mid.next;
            right = right.next.next;
        }

        ListNode leftNode,righNode;
      
        if(right == null) {  // 说明是偶数个
            left.next = null;
            leftNode = reverseListNode(head);
            righNode = mid;
        } else { // 说明是奇数个
            left.next = null;
            leftNode = reverseListNode(head);
            righNode = mid.next;
        }

        while(leftNode!=null && righNode!=null) {
            if(leftNode.val == righNode.val) {
                leftNode = leftNode.next;
                righNode = righNode.next;
            } else {
                return false;
            }
        }
       
        return leftNode==righNode;
    }

    // 反转链表
    ListNode reverseListNode(ListNode head) {
        ListNode curr = head;
        ListNode prev = null;

        while(curr!=null) {
            ListNode temp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = temp;
        }
        return prev;
    }

  
}