20.4.23 Lista simples de palíndromo 234

Complexidade temporal O (n²), complexidade espacial O (1)

Título

Por favor, determine se uma lista vinculada é uma lista vinculada ao palíndromo.

Exemplo 1:
Entrada: 1-> 2
Saída: false

Exemplo 2:
Entrada: 1-> 2-> 2-> 1
Saída: true

Avançado:
Você pode resolver esse problema com O (n) complexidade de tempo e O (1) complexidade de espaço?

Ideias de resolução de problemas

1. No começo, eu só conseguia pensar em violência e salvá-la em uma matriz;
2. Observando a discussão, vi o teste ao reverter a ordem, mas não vi os ponteiros rápidos e lentos. A complexidade do tempo dos ponteiros rápidos e lentos é O (n). Só vejo a ordem inversa e não os ponteiros rápidos e lentos.
3. 3 casos especiais: 1. Ponteiro nulo, 2. Somente um nó, 3. Existem três mesmos números no meio da lista do palíndromo com número ímpar de nós
4. Nos dois primeiros casos, basta excluí-lo;
5. No terceiro caso, como não se sabe se o número de nós é ímpar ou par durante o loop, ele só pode julgar e comparar o valor do ponto com o valor do próximo ponto e o valor do próximo ponto a cada vez;
6. Só posso suspirar que o ponteiro rápido e lento é a melhor escolha.O código é simples e fácil de entender.Eu posso entendê-lo, é adicionar dois julgamentos e testes na ordem inversa.

Código

/**
 * 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(!head || !head->next) return true;

        ListNode* pre=NULL, *curr=head;
        while(curr){
            ListNode *temp=curr->next;
            curr->next=pre;

            if(temp && curr->val==temp->val){
                ListNode *left=curr, *right=temp;
                while(left->val==right->val){
                    left=left->next;
                    right=right->next;
                    if(!left&&!right) return true;
                    if(!left || !right) break;
                }
            }

            if(temp && temp->next && curr->val==temp->next->val){
                ListNode *left=curr, *right=temp->next;
                while(left->val==right->val){
                    left=left->next;
                    right=right->next;
                    if(!left&&!right) return true;
                    if(!left || !right) break;
                }
            }

            pre=curr;
            curr=temp;
        }

        return false;
    }
};