Palindrome Linked-List

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

题目要求能在O(1)的空间和O(n)的时间内完成。基本思路如下：
1. 找到链表的中点元素，从中点元素开始reverse后半部分
2. 依次比较第一个和最后一个，并进行循环直到达到中点
3. 将后半部分再进行依次reverse恢复

其中中点元素需要根据节点数是奇数还是偶数进行区分对待。
由于是使用C++语言，因此第三步非常重要。这是因为提交后，测试案例测试完成之后会对链表进行析构删除，此时如果没有第三步，会在链表的中点元素形成一个环，这样提交的代码总是会出现”Time limit exceeded”的错误。但是如果是C#或者Java这一类语言就不用，程序运行完的时候会自动回收。这是语言特性所限制的。

---

实现上述解法用了两种方式，一种是通过遍历得到节点个数，另一种是通过两个指针，一个一次前进一步，另一个一次前进两步来实现。代码如下：

    bool isPalindrome(ListNode* head) {
        size_t n = 0;
        ListNode * p = head;
        while(p) p = p->next, ++n;
        if (n == 1 || n == 0) return true;
        if (n == 2) return head->val == head->next->val;

        ListNode * r = head;
        for(int i = 0; i < n/2; ++i) r = r->next;
        if (n % 2 != 0) r = r->next;

        //将后半部分进行reverse
        p = r->next;
        while(p)
        {
            ListNode * tmp = p->next;
            p->next = r;
            r = p;
            p = tmp;
        }

        int index = 0;
        p = head;
        ListNode * e = r; //保存尾指针
        for(index = 0; index < n/2 && p->val == r->val; ++index)
        {
            p = p->next;
            r = r->next;
        }
        bool res = index == n/2; //保存结果

        //将后半reverse的部分恢复，如果不恢复就破坏了原链表的结构，会引入
        //一个循环，程序进行链表销毁时会陷入死循环而超时！！！
        p = e->next;
        e->next = nullptr;
        for(index = 0; index < n / 2 - 1; ++index)
        {
            ListNode * tmp = p->next;
            p->next = e;
            e = p;
            p = tmp;
        }
        return res;
    }

---

    bool isPalindrome2(ListNode* head) {
        ListNode * p = head, * q = head, * mid = NULL;
        while(p && q->next) p = p->next, q = q->next->next;
        mid = p;
        if (q) p = p->next; //是奇数个节点

        //将后半部分进行reverse
        q = p->next;
        while(q)
        {
            ListNode * tmp = q->next;
            q->next = p;
            p = q;
            q = tmp;
        }

        q = head;
        ListNode * e = p; //保存尾指针
        while(q != mid && q->val == p->val) p = p->next, q = q->next;
        bool res = (q == mid);

        //将后半reverse的部分恢复
        p = e->next;
        e->next = nullptr;
        while(p != mid->next)
        {
            ListNode * tmp = p->next;
            p->next = e;
            e = p;
            p = tmp;
        }
        return res;
    }

二者比较起来，第二种实现方法的O(n)时间复杂度的系数小一些，获取中间节点较快，但是后续进行reverse和恢复操作时的判断考虑多一些。