判断链表是否为回文串以及关于回文串问题的讨论

最近在看程序员面试金典，在链表部分看到有一题问如何判断链表是否是回文串，然后想到白书中也有对最长回文子串的讨论，故想做一点总结。

一、判断链表是否为回文串

链表的数据结构是这样子滴：

public class Node {
public int val;
public Node next;

public Node(int val) {
this.val = val;
next = null;
}

public void appendToTail(Node node) {
Node curNode = this;
while (curNode.next != null) {
curNode = curNode.next;
}
curNode.next = node;
}
}

这是面试金典中的一个题目，大体的思路有以下两种

1、将链表前半段入栈，然后从后半段开始依次与栈顶元素比较。

Java代码如下：

/**
* 将链表前半部分放入栈中（注意奇数和偶数个）
* 当遍历链表后半部分的时候，一次弹出栈中的
* 元素，检验对应位置的元素是否相同。
* @param head
* @return
*/
private static boolean isPalindrome(Node head) {
//如果链表为空或者只有一个节点，那么链表是回文串
if (head == null || head.next == null) {
return true;
}
//设置快慢指针，控制入栈的节点个数为节点数的一半。
Node fastNode = head, slowNode = head;
Stack<Node> stack = new Stack<>();
while (fastNode != null && fastNode.next != null) {
stack.push(slowNode);
fastNode = fastNode.next.next;//快指针走两步
slowNode = slowNode.next;//慢指针走一步
}
//如果最后快指针是空，则链表节点数为偶数，且此时慢指针
//指向中间位置（偶数有两个中心位置）的右侧，故不需要后移。
//若不为空，则链表节点数为奇数，且慢指针指向中心位置，
//若要比较需要向后移动一位。
if (fastNode != null) {
slowNode = slowNode.next;
}
//遍历链表后半部分并以此与栈中元素比较
while (slowNode != null && !stack.isEmpty()) {
if (slowNode.val != stack.peek().val) {
return false;
}
slowNode = slowNode.next;
stack.pop();
}
return true;
}

2、递归，递归链表的前半段，返回以中心位置为轴的对应位置元素的比较结果。

Java代码：
/**
* 使用递归的思路，递归链表的前一半，返回的时候
* 依次与后半部分对应的节点比较，如果都对应相等
* 则为回文串，否则不是。
* @param head
* @return
*/
public boolean isPalindrom(Node head) {
//得到链表的长度，递归过程中需要使用
int len = getLindedLength(head);
return isPalin(head, len).isPalindrom;
}

/**
* 递归求解函数。每次向下递归时，传入的长度减2，
* 到达链表中间结束递归并开始判断，返回判断结果。
* 到达中间，即递归结束条件有三种情况：
* 长度为0：说明链表为空
* 长度为1：说明链表长度是奇数，此时指向中间节点
* 长度为2：说明链表长度为偶数，中间节点有两个
* 此时指向左边的中间节点。
* @param head
* @param length
* @return
*/
private returnStruct isPalin(Node head, int length) {
if (length == 0) {//链表为空
returnStruct struct = new returnStruct();
struct.isPalindrom = true;
struct.aimNode = null;
return struct;
} else if (length == 1) {//链表长度为奇数
returnStruct struct = new returnStruct();
//中间节点不用判断，返回它的下一个节点，用于
//递归返回后与它的上一个节点比较
struct.isPalindrom = true;
struct.aimNode = head.next;
return struct;
} else if (length == 2){//长度为偶数
//需要比较一下两个中间节点是否相同，并返回
//靠右的中间节点的下一个节点，用于递归返回
//后与靠左的中间节点的上一个节点比较
returnStruct struct = new returnStruct();
struct.isPalindrom = head.val == head.next.val ? true : false;
struct.aimNode = head.next.next;
return struct;
}
//拿到返回的比较结果
returnStruct returnStruct = isPalin(head.next, length - 2);
if (!returnStruct.isPalindrom) {//如果前面有不符合回文的节点直接返回false
return returnStruct;
}
//比较当前节点和返回的节点（也就是与当前节点以中心点为轴的对称节点）是否相同
returnStruct.isPalindrom = head.val == returnStruct.aimNode.val ? true : false;
returnStruct.aimNode = returnStruct.aimNode.next;
return returnStruct;
}

/**
* 得到指定链表的长度
* @param head
* @return
*/
private int getLindedLength(Node head) {
if (head == null) {
return 0;
}
Node node = head;
int len = 0;
while (node != null) {
len++;
node = node.next;
}
return len;
}

/**
* 用于包装递归返回值的类。
* 因为递归需要返回两个值，因此使用该类
* 来封装。
*/
class returnStruct {
//表示上一次比较是否是回文串
boolean isPalindrom;
Node aimNode;//表示与当前节点对应比较的节点
}

二、求最长回文子串

这道题是白书中的一道题。题目大意是：输入一个字符串，求其最长回文子串。判断时，忽略所有标点符号和空格，忽略大小写。但是输出的时候保持原样。

样例输入：Confuciuss say : Madam,I’m Adam.

样例输出：Madam,I’m Adam

这道题的思路也很简单

1、处理字符串，过滤标点与空格，并记录字母在原串中的位置。

2、判断过滤后的字符串是否是回文。遍历字符串，以当前位置为中心向外扩散，每次扩散长度加一并检查该子串是否是回文串。注意子串长度的奇偶性。

Java代码：

/**
* 得到最长回文字串函数。
* 遍历每个元素，从当前元素开始，依次查看以自身为中心（分奇偶）的
* 长度递增的子串是否是回文字符串，并更新当前最长子串的长度和位置
* @param string
* @return
*/
public String getLPS(String string) {
if (string == null) {
return null;
}
if (string.length() == 0) {
return "";
}
char[] strs = string.toCharArray();
//过滤无用自字符，用来存放需要查找的字符
char[] m = new char[strs.length];
//用来记录对应位置的字符在原数组中的位置
int[] p = new int[strs.length];
int mLen = 0;
for (int i = 0; i < strs.length; i++) {
if (Character.isAlphabetic(strs[i])) {
p[mLen] = i;
m[mLen++] = Character.toLowerCase(strs[i]);
}
}
int maxLen = Integer.MIN_VALUE;
int x = 0, y = 0;
//遍历数组，以当前字符为中心检查不同长度的子串是否为回文串
for (int i = 0; i < mLen; i++) {
//奇数长度的子串
for (int j = 0; i - j >= 0 && i + j < mLen; j++) {
if (m[i - j] != m[i + j]) {
break;
}
if (2 * j + 1 > maxLen) {
maxLen = 2 * j + 1;
x = p[i - j];//记录最长子串位置
y = p[i + j];
}
}
//偶数长度的子串
for (int j = 0; i - j >= 0 && i + j + 1 < mLen; j++) {
if (m[i - j] != m[i + j + 1]) {
break;
}
if (2 * j + 2 > maxLen) {
maxLen = 2 * j + 2;
x = p[i - j];
y = p[i + j + 1];
}
}
}
StringBuilder build = new StringBuilder();
for (int i = x; i <= y; i++) {
build.append(strs[i]);
}
return build.toString();
}