234. Lista vinculada de Palindrome
Enlace de tema
Fuente: LeetCode (LeetCode)
Enlace: https://leetcode-cn.com/problems/palindrome-linked-list/ Los
derechos de autor son propiedad de LeetCode . Para reimpresiones comerciales, comuníquese con la autorización oficial. Para reimpresiones no comerciales, indique la fuente.
Descripción del Título
Determine si una lista vinculada es una lista vinculada palíndromo.
Ejemplo 1:
Entrada: 1-> 2
Salida: falso
Ejemplo 2:
Entrada: 1-> 2-> 2-> 1
Salida: verdadero
Avanzado:
¿Puede resolver este problema con O (n) complejidad de tiempo y O (1) complejidad de espacio?
Análisis de temas
Después de terminar Likou 206, hagámoslo de nuevo.
1. Espacio de puntero doble (matriz) o (n): el número de la lista enlazada se coloca en la matriz. El primer puntero está al principio y el segundo al final. .
/**
* 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 {
public:
bool isPalindrome(ListNode* head) {
vector<int> nums;
ListNode* dummy = head;
while(dummy){
nums.push_back(dummy->val);
dummy = dummy->next;
}
int n = nums.size();
int left = 0;
int right = n - 1;
while(left < right){
if(nums[left] != nums[right]){
return false;
}
left++;
right--;
}
return true;
}
};
2. Recursion + espacio de pila de recursividad de doble puntero o (n)
/**
* 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 {
public:
ListNode * global;
bool isPalindrome(ListNode* head) {
global = head;
return recursion(head);
}
bool recursion(ListNode* head){
if(!head){
return true;
}
if(!recursion(head->next)){
return false;
}
if(global->val != head->val){
return false;
}
global = global->next;//注意 别忘了
return true;
}
};
3. Stack-space o (n) La parte inferior de la pila corresponde a la cabeza y el final de la pila corresponde a la cola. A juzgar por la cabecera de la lista vinculada y la parte superior de la pila
/**
* 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 {
public:
bool isPalindrome(ListNode* head) {
stack<ListNode*> stack;//栈内存储指针
ListNode * dummy = head;
while(dummy){
stack.push(dummy);
dummy = dummy->next;
}
dummy = head;
while(dummy){
if(dummy->val != stack.top()->val){
return false;
}
dummy = dummy->next;
stack.pop();
}
return true;
}
};
Avanzado
4. Punteros
rápidos y lentos (generalmente utilizados en listas vinculadas) -espacio o (1) Los punteros lentos van un paso, los punteros rápidos van dos pasos, cuando los punteros rápidos alcanzan nullptr, los punteros lentos a la posición donde está la segunda mitad del enlace la lista comienza, los punteros rápidos apuntan a la cabeza, los punteros lentos y los punteros lentos Inversión posterior (pregunta 206 de la lista enlazada inversa)) El
puntero de velocidad val es igual mientras se mueve desigual para devolver falso
https://leetcode-cn.com/problems/palindrome- lista-enlazada / solución / wo-de-kuai-man-zhi -zhen-du-cong-tou-kai-shi-gan-ju /