力扣热题100 - 链表：回文链表

题目描述：

题号：234

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

解题思路：

思路一：双指针

算法思路：利用 206 题 - 反转链表的函数

1、先找到链表的中间节点

2、然后反转后半段链表，并返回后半段链表的头节点

3、对比反转后的后半段链表和前半段链表

证明：假设原链表：1 -> 2 -> 2 -> 1

则反转后链表：1 -> 2 -> 2 <- 1 

此时的左右指针分别指向 最左 和 最右 两个 1

时间复杂度：O(N)

空间复杂度：O(1)

C++

// C++
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
    ListNode* middleNode(ListNode* head) {
        ListNode *fast = head, *slow = head;
        while(fast->next != nullptr && fast->next->next != nullptr) {
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;
    }

    ListNode* reverseNode(ListNode* head) {
        ListNode *pre = nullptr, *cur = head;
        while(cur) {
            ListNode *temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
    
public:
    bool isPalindrome(ListNode* head) {
        if(head == nullptr) {
            return true;
        }
        ListNode *mid = middleNode(head);
        ListNode *head2 = reverseNode(mid->next);

        while(head != nullptr && head2 != nullptr) {
            if(head->val != head2->val) {
                return false;
            }
            head = head->next;
            head2 = head2->next;
        }
        return true;
    }
};

go

// go
/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func middleNode(head *ListNode) *ListNode {
    fast := head
    slow := head
    for fast.Next != nil && fast.Next.Next != nil {
        fast = fast.Next.Next
        slow = slow.Next
    }
    return slow
}

func reverseNode(head *ListNode) *ListNode {
    var pre, cur *ListNode
    pre = nil
    cur = head

    for cur != nil {
        temp := cur.Next
        cur.Next = pre
        pre = cur
        cur = temp
    }
    return pre
}

func isPalindrome(head *ListNode) bool {
    if head == nil {
        return true
    }
    mid := middleNode(head)
    head2 := reverseNode(mid.Next)
    for head != nil && head2 != nil {
        if head.Val != head2.Val {
            return false
        }
        head = head.Next
        head2 = head2.Next
    }
    return true
}