14_234. 回文链表

//反转整个链表
/**
 * 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 true;
        }
        ListNode reverseList = null;
        ListNode temp = head;
        
        while (temp != null){
            reverseList = new ListNode(temp.val, reverseList);
            temp = temp.next;
        }
        ListNode p1 = reverseList;
        temp = head;
        while (temp != null){
            if (temp.val == p1.val){
                temp = temp.next;
                p1 = p1.next;
            }else {
                return false;
            }
        }
        return true;
    }
}

//利用数组存储，然后双指针头尾比较
/**
 * 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) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        while (head != null) {
            arrayList.add(head.val);
            head = head.next;
        }
        int begin = 0;
        int end = arrayList.size()-1;
        for (;begin <= end; begin++,end--){
            if (arrayList.get(begin) != arrayList.get(end)){
                return false;
            }
        }
        return true;
    }
}

//递归
/**
 * 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 {
    private ListNode frontNode;
    public boolean isPalindrome(ListNode head) {
        frontNode = head;
        return recursiveCheck(head);
    }
    private boolean recursiveCheck (ListNode currNode) {
        if (currNode != null) {
            if (!recursiveCheck(currNode.next)) { //如果currNode.val != frontNode.val就一直返回false
                return false;
            } 


            if (currNode.val != frontNode.val){
                return false;
            }
            frontNode = frontNode.next;
        }
        return true;
    }
}

//快慢指针，反转一半链表
/**
 * 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 || head.next == null) {
            return true;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while (fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }

        ListNode rev = reverseList(slow.next);
        ListNode p1 = head;
        while (rev != null) {
            if (rev.val != p1.val){
                return false;
            }
            rev = rev.next;
            p1 = p1.next;
        }
        return true;
        
        
        
    }

    private ListNode reverseList(ListNode head){
        ListNode prev = null;
        ListNode cur = head;
        while (cur != null){
            ListNode temp = cur.next;
            cur.next = prev;
            prev = cur;
            cur = temp;
        }
        return prev;
    }
}