20.4.23 Lista simple de palíndromos 234

Complejidad de tiempo O (n²), complejidad de espacio O (1)

Titulo

Determine si una lista vinculada es una lista vinculada de palíndromo.

Ejemplo 1:
Entrada: 1-> 2
Salida: falso

Ejemplo 2:
Entrada: 1-> 2-> 2-> 1
Salida: verdadero

Avanzado:
¿Puede resolver este problema con la complejidad de tiempo O (n) y la complejidad de espacio O (1)?

Ideas para resolver problemas

1. Al principio, solo podía pensar en la violencia y guardarla en una matriz;
2. Mirando la discusión, vi la prueba mientras invertía el orden, pero no vi los punteros rápidos y lentos. La complejidad temporal de los punteros rápidos y lentos es O (n). Solo veo el orden inverso y no los punteros rápidos y lentos. Es O (n²);
3. 3 casos especiales: 1. Puntero nulo, 2. Solo un nodo, 3. Hay tres mismos números en el medio de la lista palíndromo con un número impar de nodos
4. En los primeros dos casos, simplemente excluirlo;
5. En el tercer caso, debido a que no se sabe si el número de nodos es impar o par durante el ciclo, solo puede juzgar y comparar el valor del punto con el valor del siguiente punto y el valor del siguiente punto cada vez
6. Solo puedo suspirar que el puntero rápido y lento es la mejor opción. El código es simple y fácil de entender. Aunque puedo entenderlo, es agregar dos juicios y pruebas en el orden inverso.

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;
    }
};