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;
     }
 }