证明回文链----要求时间O（n）、空间O（1）

1. 回文链表

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

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

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

（1）解法一：将链表存储成数组进行判断回文

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head==null){
            return false; 
        }
        else{
            ListNode tail=head;
            int n=1;
            while(tail.next!=null){
                tail=tail.next;
                n++;
            }
            if(head==tail){
                return true;
            }
            else{
                int array[]=new int[n];
                tail=head;
                int k=0;
                while(tail!=null){
                    array[k++]=tail.val;
                    tail=tail.next;
                }
                int i=0,j=n-1;
                while(i<=j){
                    if(array[i]==array[j]){
                        i++;
                        j--;
                        continue;
                    }
                    else{
                        return false;
                    }
                }
            }
        }
        return true;
    }
}

时间复杂度为：O（n），空间复杂度也为O（n）

（2）解法二：空间复杂度降为O（1），使用翻转链表法将前一半链表翻转即可。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        int n = 0;
        ListNode p = head;
        while (p != null) {
            n++;
            p = p.next;
        }
        if (n == 0) {
            return false;
        }
        else if (n == 1) {
            return true;
        }
        else {
            p = head;
            ListNode midHead;
            ListNode headNew = new ListNode(0, null);
            int length = n / 2;
            ListNode pre=p;
            ListNode q=p;
            while (length > 0) {
                q=p.next;
                pre=p;
                p.next = headNew.next;
                headNew.next = p;
                p = q;
                length--;
            }
            headNew = headNew.next;
            if (n % 2 != 0) {
                midHead = p.next;
            } else {
                midHead = p;
            }
            while (headNew!=null&&midHead != null) {
                if (headNew.val == midHead.val) {
                    headNew = headNew.next;
                    midHead = midHead.next;
                    continue;
                } else {
                    return false;
                }
            }
        }
        return true;
    }
}

时间复杂度为：O（n），空间复杂度为O（1）