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

示例 1:

输入: 1->2
输出: false
示例 2:

输入: 1->2->2->1
输出: true
进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

问题：

1、当链表的个数是奇数时，为了使slow往后移动一个单位，需要用到此判断，为什么fast的下一个结点为NULL设为条件是错误的呢？

  1.  // if (fast->next == NULL) 
  2.         if (fast != NULL) {
  3.             slow = slow->next;
  4.        }
  5. // Line 39: Char 17: runtime error: member access within null pointer of type 'struct ListNode' [solution.c]

image.png
第 39 行：字符 17：运行时错误：“struct ListNode”类型的空指针内的成员访问 [solution.c]

2、
image.png上面的if判断不能写上去，因为它是不等于NULL就移位

代码：

1.快慢指针方法

////

  1. /**
  2.  * Definition for singly-linked list.
  3.  * struct ListNode {
  4.  *     int val;
  5.  *     struct ListNode *next;
  6.  * };
  7.  */
  9. struct ListNode * reverNode(struct ListNode * head) {
  10.     if(head->next == NULL) {
  11.         return head;
  12.     }
  13.     // 使用迭代的方法会效率高一点
  14.     struct ListNode * pre = NULL;
  15.     struct ListNode * cur = head;
  16.     struct ListNode * nxt = head;
  17.     while(cur != NULL) {
  18.         nxt = cur->next;
  19.         cur->next = pre;
  20.         pre = cur;
  21.         cur = nxt;
  22.     }
  23.     return pre;
  24. }
  26. bool isPalindrome(struct ListNode* head){
  27.     // 如果head是空或者下一个指针是空的话，直接返回true
  28.     if (head == NULL || head->next == NULL) {
  29.         return true;
  30.     }
  32.     // 定义快慢指针
  33.     struct ListNode * slow = head;
  34.     struct ListNode * fast = head;
  36.     // 让其到对应的位置，考虑奇数条件
  37.     while(fast != NULL && fast->next != NULL) {
  38.         slow = slow->next;
  39.         fast = fast->next->next;
  40.         // if (fast->next == NULL) 
  41.     }
  43.      if (fast != NULL) {
  44.         slow = slow->next;
  45.     }
  47.     // 应该是有fast指向NULL的可能，所以不能这样判断
  48.     // if (fast->next == NULL) {
  49.     //     slow = slow->next;
  50.     // }
  53.     // 对slow指针后的结点进行翻转
  54.     struct ListNode * right = reverNode(slow);
  55.     struct ListNode * left = head;
  57.     // 两边同时进行迭代对比
  58.     while (right != NULL) {
  59.         if(right->val != left->val) {
  60.             return false;
  61.         }
  62.         right = right->next;
  63.         left = left->next;
  64.     }
  65.     return true;
  66. }