判断一个链表是否为回文结构 【题目】 给定一个链表的头节点head，请判断该链表是否为回 文结构。 例如： 1->2->1，返回true。 1->2->2->1，返回true。 15->6->15，返回true。 1->2->3，返回false。 进阶： 如果链表长度为N，时间复杂度达到O(N)，额外空间复杂 度达到O(1)。

方式1：借助栈 空间辅助度是O(N)

方式2： 借助栈 空间复杂度是 O(n/2)。只存后半个链表 

方式3： 反转后半个链表  最后再反转回来

package my_basic.class_3;

import java.util.Stack;

//是否是回文结构  121  1221，
public class Code_11_IsPalindromeList {
    public static class Node{
        int value;
        Node next;
        public Node(int value) {
            super();
            this.value = value;
        }
    }
    
    //need extra(n) space 栈辅助
    public static boolean isPalindrome1(Node head) {
        Stack<Node> stack = new Stack<Node>();
        Node cur = head;
        while(cur != null) {
            stack.push(cur);
            cur = cur.next;
        }
        while (head != null && !stack.empty()) {
            if (head.value != stack.pop().value) {
                return false;
            }
            head = head.next;
        }
        if (head==null) {
            System.out.println("head null");
        }
        return true;
    }
    
    //need n/2 extra space 栈辅助
    public static Boolean isPalindrome2(Node head) {
        Stack<Node> stack = new Stack<Node>();
        if (head == null || head.next == null) {
            return true;
        }
        Node right = head.next;
        Node cur = head;
        if (cur.next!=null || cur.next.next !=null) {
            cur = cur.next.next;
            right = right.next;
        }
        while (right != null) {
            stack.push(right);
            right = right.next;
        }
        while(!stack.empty()) {
            if (head.value != stack.pop().value) {
                return false;
            }
            head = head.next;
        }
        return true;
    }
    
    //need O(1) extra space 反转半个链表
    public static Boolean isPalindrome3(Node head) {
        if (head == null || head.next == null) {
            return true;
        }
        Node n1 = head;
        Node n2 = head;
        while (n2.next != null && n2.next.next!=null) {
            n1 = n1.next;  //mid
            n2 = n2.next.next; //last
        }
        n2 = n1.next;  //右边第一个节点
        n1.next = null;
        Node n3 = null;
        while (n2 != null) {   /*反转右半部分*/
            n3 = n2.next;
            n2.next = n1;
            n1 = n2;
            n2 = n3;
        }
        n3 = n1;  //n3->last node
        n2 = head;
        boolean res = true;
        while (n2 != null && n1 != null) {
            if (n2.value != n1.value) {
//                return false;   不能return  还要把链表反转回来
                res = false;
                break;
            }
            n2 = n2.next;
            n1 = n1.next;
        }
        
        n1 = n3.next;
        n3.next = null;
        while (n1 != null) { // recover list
            n2 = n1.next;
            n1.next = n3;
            n3 = n1;
            n1 = n2;
        }
        return res;
        
    }
    
    
    public static void printLinkedList(Node node) {
        System.out.print("Linked List: ");
        while (node != null) {
            System.out.print(node.value + " ");
            node = node.next;
        }
        System.out.println();
    }

    
    public static void main(String[] args) {
        Node head = null;
        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(2);
        head.next.next.next = new Node(2);
//        head.next.next.next.next = new Node(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.print(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");

    }
}