LeetCode之Palindrome Linked List

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 /*思路：为了判断链表是否为回文，需要对比链表中第一个、倒数第一个，第二个、倒数第二个
 节点...等的值。由于链表不支持随机访问，所以直接这样做的时间复杂度为O(n^2)。
 为了获得更好的时间复杂度方法，观察上面步骤，第一个与倒数第一个，第二个与倒数第二个，
 等等，发现如果有个指针能够倒着走，就能够获得O(n)的时间复杂度。所以，想法来了，直接将
 后半部分链表翻转即可。方法步骤如下：
 1.找到链表的中间节点；
 2.翻转后半部分的链表；
 3.对比前后半部分链表，判断是否为回文；
 4.将链表恢复为原样，返回结果。*/
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(head == nullptr || head->next == nullptr) return true;
        //1.找到链表的中间结点
        ListNode *slow = head, *fast = head;
        while(fast->next != nullptr && fast->next->next != nullptr){
            fast = fast->next->next;
            slow = slow->next;
        }
        
        //2.将后半段的链表进行翻转
        ListNode* qhead = slow->next;
        qhead = reverse(qhead);
        
        //3.对比前后半部分链表，判断链表是否为回文
        bool res = true;
        while(qhead != nullptr){
            if(head->val != qhead->val) res = false;
            head = head->next;
            qhead = qhead->next;
        }
        
        //4.将后半部分链表恢复原样
        qhead = reverse(qhead);
        slow->next = qhead;
        return res;
    }
    
    ListNode* reverse(ListNode* head){
        //函数功能：翻转链表
        if(head == nullptr || head->next == nullptr) return head;
        ListNode node(-1);
        node.next = head;
        head = head->next;
        node.next->next = nullptr;
        while(head != nullptr){
            ListNode *p = head;
            head = head->next;
            p->next = node.next;
            node.next = p;
        }
        return node.next;
    }
};