链表回文判断（C++）

题目描述：

对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。

给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。

测试样例：

1->2->2->1

返回：true

思路：　　
　　由于空间复杂度要求为O(1)，也就是说临时占用空间和输入数据规模无关，因此无法利用数组或者是栈进行判断。因此先找到中间位置将后半部分指针翻转，然后两端分别比较。注意这种方法会修改原链表，但是空间复杂度要求为O(1)也只能这么做了。

程序运行流程：
　　1、利用快慢指针找到中间的位置（起初均指向头结点，然后pSlow一次走一步，pFast一次走两步。注意不需要区分链表结点个数是奇数还是偶数）；

　　2、将后半部分指针翻转；
　　3、最后再进行一次遍历，一个从前向后，一个从后向前。

下图是演示图（分为链表结点个数奇数和偶数两种情况），当pFast或pFast->next到达尾部（为NULL）时，pSlow正好到达中间位置。其中当链表结点个数为偶数时，pFast首先变为NULL；当链表结点个数为奇数时，pFast->next首先变为NULL。

　　

　　

　　

　　

代码：

 /*
 本程序说明：

 时间限制：3秒 空间限制：32768K 热度指数：8332
 本题知识点： 链表 栈

 题目描述
 对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。
 给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。
 测试样例：
 1->2->2->1
 返回：true

 */

 #include <iostream>
 using namespace std;

 struct ListNode {
     int val;
     struct ListNode *next;
     ListNode(int x) : val(x), next(NULL) {}
 };

 //链表结点构造
 ListNode*  create_list_node(int val)
 {
     ListNode* pNode = new ListNode(val);
     return pNode;
 }
 //链表结点连接
 void connect_list_node(ListNode* pCur, ListNode* pNext)
 {
     pCur->next = pNext;
 }

 class PalindromeList {
 public:
     bool chkPalindrome(ListNode* A) {
         // write code here
         ListNode* pSlow = A;
         ListNode* pFast = A;

         while(pFast != NULL && pFast->next != NULL)
         {
             pSlow = pSlow->next;
             pFast = pFast->next->next;
         }
         //反转链表后半部分指针
         ListNode* prev = pSlow;//临时保存用
         pSlow = pSlow->next;
         prev->next = NULL;//最中间的点的next置为NULL
         while(pSlow != NULL)
         {
             cout<<pSlow->val<<endl;
             ListNode* tmp = pSlow->next;//保存后面的结点
             pSlow->next=prev;
             prev = pSlow;
             pSlow = tmp;
         }

         ListNode* pForward = A;//指向头结点
         ListNode* pBackward= prev;//指向链表最后一个结点

         while(!(pForward == pBackward || pForward->next == pBackward))
         {
             if(pForward->val != pBackward->val)
                 return false;
             pForward = pForward->next;
             pBackward = pBackward->next;
         }
         return true;
     }
 };

 void test()
 {
     //创建结点
     ListNode* pNode1 = create_list_node();
     ListNode* pNode2 = create_list_node();
     ListNode* pNode3 = create_list_node();
     ListNode* pNode4 = create_list_node();
     ListNode* pNode5 = create_list_node();
     ListNode* pNode6 = create_list_node();
     ListNode* pNode7 = create_list_node();
 //    ListNode* pNode8 = create_list_node(45);
 //    ListNode* pNode9 = create_list_node(-7);

     //连接结点
     connect_list_node(pNode1,pNode2);
     connect_list_node(pNode2,pNode3);
     connect_list_node(pNode3,pNode4);
     connect_list_node(pNode4,pNode5);
     connect_list_node(pNode5,pNode6);
     connect_list_node(pNode6,pNode7);
 //    connect_list_node(pNode7,pNode8);
 //    connect_list_node(pNode8,pNode9);

     PalindromeList test;

     bool flag=test.chkPalindrome(pNode1);
     cout<<flag<<endl;

 }

 int main()
 {
     test();
     return ;
 }

欢迎交流。