1链表：回文链表（leetcode 234）

　　最近想学习一波数据结构与算法，之前也有学习过部分，但是感觉时间久了会忘记的差不多了，而且学习的不是很系统，就是自己突然想到某个知识点就去学习，也有在leetcode上刷题，也是久了就忘记了，自己写的代码就看不懂了，但是觉得数据结构和算法挺重要的，业余时间也没有别的事情做，就再啃啃喽。

　　觉得知识点看了，懂了如何实现，但是自己用代码实现起来还是有点吃力，总是有问题，基础太差了。刚开始花费的时间很长，不过虽然自己基础差学起来耗时，但是看到代码通过的那一刻还是开心的，觉得值得，也可能代码是自己想了好久才写出来的，还存在问题，也可能是百思不得其解看了大佬们的思路才写出来的，也可能看了大佬们的分享也还是费九牛二虎之力才解决，不论怎样，也算是个进步，为了加深印象以及自己记录一些东西方便后续复习，就打算写点博客。

　　今天学习链表，碰到了回文串的问题，刚开始不知道怎么去想，单链表又不能首尾同时处理来比较节点内容，然后想起链表其他问题的快慢指针（慢的跑一个节点，快的跑两个节点），然后思路大概就有了。

　　遍历链表，找到中间节点，在遍历的同时将前半部分逆序，然后将链表分两个小链表，同时遍历两个小链表，比较节点内容。在实现的时候对于链表节点个数为奇数和偶数的情况是不一样处理的，奇数的话就用中间把中间节点去掉（不比较），然后开始比较，偶数的话用当前节点作为第二段链表的首节点，当前节点的前驱节点作为第一段链表的头节点，比较两个链表即可。

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

题目描述：

请判断一个链表是否为回文链表。

示例 1:

输入: 1->2
输出: false

示例 2:

输入: 1->2->2->1
输出: true

进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

在开始写的时候，要反转链表，单链表一般需要三个指针，一个用来标识当前操作的节点，一个用来标识当前节点的前驱，一个用来标识当前节点的后继节点（因为是单链表，如果在改变当前节点的next指针之前不保存后继节点，那么就找不到后边的链表了），考虑到将头节点单独处理，写了代码：

/**
 * 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) {
        if (NULL == head)
            return true;
        
        //寻找链表的中间节点，并在此过程中将前半部分逆序
        ListNode* pLowCurr = NULL;//当前操作节点，也是即将找到的中间节点
        ListNode* pPre = NULL;
        ListNode* pNext = NULL;
        ListNode* pFast = NULL;
        
        pLowCurr = pFast = head;
        
        //如果快指针到达链表尾部，那么慢指针就处于链表的中间位置
        while (pFast && pFast->next)
        {
            //反转前半部分链表
            if (pLowCurr == head)
            {
                pPre = pLowCurr;
                pNext = pLowCurr->next;
                pPre->next = NULL;
                
                pLowCurr = pNext;
                pNext = pNext->next;
                pFast = pNext;
            }
            else
            {
                pLowCurr->next = pPre;
                pPre = pLowCurr;
                pLowCurr = pNext;
                pNext = pLowCurr->next;
                //pFast = pNext->next;
                pFast = pFast->next->next;
            }
        }
        
        if (pFast == NULL)
        {
            //偶数个节点
            pLowCurr->next = pNext;
        }
        else
        {
            //奇数个节点
            pLowCurr = pNext;
        }
        
        //比较两段链表是否相等
        while (pPre && pLowCurr)
        {
            if (pPre->val != pLowCurr->val)
            {
                return false;
            }
            pPre = pPre->next;
            pLowCurr = pLowCurr->next;
        }
        return true;
    }
};

后来在出问题分析的时候发现代码比较不友好，重复的代码太多了，然后就考虑把头节点和其余节点一起考虑，发现也是可以的，也可能是自己基础实在太差了，对于链表的操作觉得思路很清晰了，可是代码实现起来还是有漏洞，不断的在纸上画，然后逐语句分析，还是比较容易找问题的，发现自己可能脑子反应慢点，逻辑思维不太好，还是纸上画画比较清楚点，然后整理了下，代码如下：

/**
 * 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) {
        if (NULL == head)
            return true;
        
        //寻找链表的中间节点，并在此过程中将前半部分逆序
        ListNode* pLowCurr = NULL;//当前操作节点，也是即将找到的中间节点
        ListNode* pPre = NULL;
        ListNode* pNext = NULL;
        ListNode* pFast = NULL;
        
        pLowCurr = pFast = head;
        
        //如果快指针到达链表尾部，那么慢指针就处于链表的中间位置
        while (pFast && pFast->next)
        { 
            //超时优化代码
            pFast = pFast->next->next;//快指针先跑起来
            pNext = pLowCurr->next;//保存后继节点
            pLowCurr->next = pPre;//更新后继节点
            pPre = pLowCurr;//更新前驱节点
            
            pLowCurr = pNext;//更新当前节点
        }
        
        if (pFast != NULL)
        {
            //奇数个节点
            pLowCurr = pLowCurr->next;
        }
        
        //比较两段链表是否相等
        while (pPre && pLowCurr)
        {
            if (pPre->val != pLowCurr->val)
            {
                return false;
            }
            pPre = pPre->next;
            pLowCurr = pLowCurr->next;
        }
        return true;
    }
};

在实现的时候出现了两个问题：

　　1、在处理完原链表之后，比较两个小链表的时候，只顾着比较，没有移动当前操作节点，看到时间超过限制，不够仔细，没发现指针问题，以为是时间复杂度大于O(n)，可是分析遍历链表复杂度O(n)，遍历比较小链表O(n/2)，总体来说还是O(n)，后来才发现，自己实在是太粗心了。哎。。。

　　2、跑的快（走两个节点）的指针依赖于其他指针，导致不好处理，想着只要跑得快的指针有了初值，即指向头节点，那么无论怎么情况，都会比其余的指针跑的快，也就是说在原链表节点被改变之前就已经跑过这个节点了，所以，通过自己next来遍历就好了，但是要在头节点next指针被改变之前就操作。

写的代码效率还不是很高，希望能通过记录博客多学点东西把，加油！