LeetCode OJ：Palindrome Linked List（回文链表判断）

Given a singly linked list, determine if it is a palindrome.

Follow up:
Could you do it in O(n) time and O(1) space?

判断一个链表是否为回文链表，有很多方法都可以进行判断，可以先遍历链表然后将值全部存储到vector之中，也可以遍历链表然后将list中的值都压倒堆栈中再和List进行比较，

但是想要达到题目上面的 时间复杂度为O（n），而空间复杂度为O（1）还要用到递归：

首先是不用递归的方法（使用一个栈）：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        ListNode * tmpHead = head;
        stack<int> lt;
        while (tmpHead){
            lt.push(tmpHead->val);
            tmpHead = tmpHead->next;
        }

        while (!lt.empty()){
            if (head->val != lt.top()) return false;
            lt.pop();
            head = head->next;
        }
        return true;
    }
};

java版本的代码：

public class Solution {
    public boolean isPalindrome(ListNode head) {
        ListNode p = head;
        Stack<ListNode> s = new Stack<ListNode>();
        while (p != null) {
            s.push(p);
            p = p.next;
        }
        while(!s.isEmpty()){
            if(head.val != s.pop().val)
                return false;
            head = head.next;
        }
        return true;
    }
}

首先上面这个空间复杂度是不满足要求的，再者，既然想到了将元素压入栈中，那么结合递归的话，应该就能做到空间复杂度O（1）了，应为上面的方法用到了堆栈，与递归能很好的结合：

class Solution{
private:
    ListNode * theHead;

public:
    bool isPalindrome(ListNode* head) {
        theHead = head;　　//先将head保存到一个theHead里面，便于与后面的递归了得指针相比较。
        return valid(head);
    }

    bool valid(ListNode * first)
    {
        if (first == NULL) return true;
        if (valid(first->next) == false) return false;
        if (first->val == theHead->val){
            theHead = theHead->next;
            return true;
        }
        else
            return false;
    }
};

因为道理比较简单，所以就不一一赘述了。

java版本的代码如下所示：

public class Solution {
    ListNode helper;
    public boolean isPalindrome(ListNode head) {
        helper = head;
        return isValid(head);
    }

    public boolean isValid(ListNode first){
        if(first == null) return true;
        if(isValid(first.next) == false) return false;
        if(first.val == helper.val){
            helper = helper.next;
            return true;
        }else
            return false;
    }
}