判断链表是是否是回文

package com.lhs.programerInterview.implement;

import java.util.Scanner;
import java.util.Stack;

/**
* 判断一个链表是是否是回文结构
* 进阶：如果链表的长度为N，时间复杂度达到O(N),额外的空间复杂度是O(1)。
* @author lhs94
* @date 2017-10-24
*/
public class JudgePalindromel {


public static void main(String[] args) {
JudgePalindromel test = new JudgePalindromel();
Scanner sc = new Scanner(System.in);
Node head;
//使用尾插法构造单链表
while(sc.hasNextLine()){
String[] input = sc.nextLine().split(" ");
head = new Node(input[0]);
Node tailNode = head;//tailNode指向尾节点
for (int i = 1; i < input.length; i++) {
Node node = new Node(input[i]);
tailNode.next = node;//把新节点定义为新的尾节点
tailNode = node;
}
tailNode.next = null;//尾节点结束

boolean result1 = test.isPalindromel_1(head);
System.out.println("result :" + result1 );
boolean result2 = test.isPalindromel_2(head);
System.out.println("result :" + result2 );
boolean result3 = test.isPalindromel_3(head);
System.out.println("result :" + result3 );
}
}
/**
* 使用栈来判断，因为若是回文，进栈的顺序和出栈的顺序是一样的。否则不是回文
* 此方法的时间复杂度是O(N),空间复杂度也是O(N)
* @param head
* @return
*/
public boolean isPalindromel_1(Node head){
Stack<Node> stack = new Stack<Node>();
Node cur = head;
while(cur != null){
stack.push(cur);
cur = cur.next;
}
while(head != null){
if(!head.value.equals(stack.pop().value)){
return false;
}
head = head.next;
}
return true;
}
/**
* 可以把优化上面的栈的实现，因为若是回文，那么并不需要把所有的元素都入栈中，只压入一半即可。
* 假设链表的长度是N，如果N是偶数，那么，前N/2的节点叫做左半区，后N/2叫做后半区；
* 如果是奇数，忽略中间的那个数，还是前一半是左半区，后一半是右半区；
* 把后一半压入栈中，然后比较栈顶到栈底的元素与链表的前一半是否一样。
* 此方法的时间复杂度是O(N),空间复杂度是O(N/2).
* @param head
* @return
*/
public boolean isPalindromel_2(Node head){
if(head == null || head.next == null){
return true;
}
Node right = head.next;
Node cur = head;
while(cur.next != null && cur.next.next != null){
right = right.next;
cur = cur.next.next;
}
Stack<Node> stack = new Stack<Node>();
while(right != null){
stack.push(right);
right = right.next;
}
while(!stack.isEmpty()){
if(!head.value.equals(stack.pop().value)){
return false;
}
head = head.next;
}
return true;
}
/**
* 进阶：
* 不需要栈和其他数据结构，只用有限的几个变量，其额外空间复杂度是O(1)，可以在时间复杂度为O(N)内完成所有的过程。
* 1.首先改变链表右边区的结构，使整个右边区反转，最后指向中间节点；
* 2.leftStart 和rightStart 同时向中间点移动，移动每一步，比较leftStart和rightStart的节点的值，看是否一样。
* 若一样，说明是回文，否则不是回文。
* 3.不管最后返回的是true 还是 false，在返回前，都应该把链表恢复成原来的样子。
* 4.链表恢复成原来的结构后，返回检查结果。
* @param head
* @return
*/
public boolean isPalindromel_3(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;//n1 -> 中部
n2 = n2.next.next;// n2 -> 结尾
}

n2 = n1.next;//右半部分第一个节点
n1.next = null;// mid.next -->null

Node n3 = null;
while(n2 != null){
n3 = n2.next;// n3-->保存下一个节点
n2.next = n1;//下一个反转节点
n1 = n2;//n1移动
n2 = n3;//n2移动
}
n3 = n1;//n3保存最后一个节点
n2 = head;//n2-->左边第一个节点
boolean res = true;
while(n1 != null && n2 != null){//检查回文
if(!n1.value.equals(n2.value)){//对象判断是否相等，需用equeals(),"=="判断时是不相等的，即使内容一样
res = false;
break;
}
n1 = n1.next;//右边到中部
n2 = n2.next;//左边到中部
}
n1 = n3.next;
n3.next = null;
while(n1 != null){//恢复链表
n2 = n1.next;
n1.next = n3;
n3 = n1;
n1 = n2;
}
return res;
}
}