编写一个函数，检查输入的链表是否是回文的。

示例 1：
输入： 1->2
输出： false 

示例 2：
输入： 1->2->2->1
输出： true 

进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

分析：

方法1：栈

利用栈先进后出的特点，将每个节点入栈，在出现与原节点依次进行比较。

时间复杂度：O(n)
空间复杂度：O(n)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        //创建栈
        Deque<ListNode> stack = new ArrayDeque<>();
        //记录头节点
        ListNode temp = head;
        //入栈
        while(temp != null){
            stack.addLast(temp);
            temp = temp.next;
        }
        //出栈比较
        while(!stack.isEmpty()){
            //不一样
            if(stack.pollLast().val != head.val){
                return false;
            }
            head = head.next;
        }
        return true;
    }
}

方法2：快慢指针

定义快慢双指针，一个一次遍历一个节点，一个一次遍历两个节点，同时遍历，当快指针遍历完成时，慢指针刚好遍历一半，将慢指针后面的链表反转和原先链表比较即可。

时间复杂度：O(n)
空间复杂度：O(1)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        //创建快慢节点
        ListNode slow = head, fast = head;
        //遍历，寻找中点
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        //反转慢节点
        ListNode node = null;
        while(slow != null){
            ListNode temp = slow.next;
            slow.next = node;
            node = slow;
            slow = temp;
        }
        //比较两节点
        while(node != null){
            //不同
            if(head.val != node.val){
                return false;
            }
            head = head.next;
            node = node.next;
        }
        return true;
    }
}

题目来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-linked-list-lcci