Determinar la parte posterior archivo en una sola lista

entrada START ⼀ sola cabeza de los nodos de la lista, se determina que el número no se encuentra en la parte posterior lista para el archivo

/**
* 单链表节点的定义：
* public class ListNode {
* int val;
* ListNode next;
* }
*/
boolean isPalindrome(ListNode head);

Entrada: 1-> 2-> salida nula: falsa
de entrada: 1-> 2-> 2-> 1- > nula de salida: true

Analizando palíndromo, el más utilizado es el doble puntero.
Pero ni un solo revés recorrido de lista enlazados, puede usar doble puntero

Método uno: lista de vertidos

La lista original invertida, una nueva lista se almacena, y luego comparar estas dos listas si el mismo
tiempo y el espacio complejidad del algoritmo es O (N)

Método 2: atravesar Binary Tree - Estructura Pila

Después ⼆ árbol por la que atraviesa idea, sin lista original invertida explícita puede recorrer la lista en orden inverso

Enumerar tanto la estructura recursiva, la estructura de árbol, sino una lista de derivados ⽣. Bueno, la lista puede realmente tener un orden previo de recorrido y orden posterior:

void traverse(ListNode head) {
	// 前序遍历代码
	traverse(head.next);
	// 后序遍历代码
}

Si quiero para imprimir valores positivos val en la lista enlazada, puede escribir código de posición de desplazamiento pre-orden;
por otro lado, si desea invertir recorrer la lista, puede operar en una posición orden posterior recorrido:

//倒序打印单链表中的元素值
void traverse(ListNode head){
	if(head == null) return;
	traverse(head.next);
	//后序遍历代码
	print(head.val);
}

Mimic de vuelta doble puntero al archivo es determinado para conseguir una función
de tiempo y espacio complejidad del algoritmo es O (N)

//左侧指针
ListNode left;

boolean isPalidrome(ListNode head){
	left = head;
	return traverse(head);
}
boolean traverse(ListNode right){
	if(right == null) return true; //递归终点：right到达最右侧 ==null
	boolean res = traverse(right.next);
	//后序遍历代码
	res = res && (right.val == left.val); //right到达最右侧返回后，递归里的right是最后一个节点，res是true
	left = left.next;
	return res;
}

Centro Nuclear lógica ponderado: de hecho, la lista de nodos START ⼀ puso una pila, y luego una probabilidad, esta vez el orden de los elementos es lo contrario, pero nuestro interés es apilar Uso de las funciones recursivas ⽽ ya.

Método tres: sólo se revirtió parcialmente después de la lista del punto medio

La complejidad tiempo total del algoritmo es O (N), la complejidad espacial es O (1)

1. Para encontrar el punto medio de la primera lista por la velocidad [bis puntero] Puntero

ListNode slow, fast;
slow = fast = head;
while(fast != null && fast.next){ //根据fast判断while条件，fast走到最后的前一个位置，下一步需要分情况
	slow = slow..next;
	fast = fast.next.next;
}	
//slow指针现在指向链表中点

2. Si el puntero no apunta nula rápido, descripción de la lista de longitud es un número impar, por lo que lento paso más allá y
esta inversión está empezando lenta

3. comienzo lento de detrás de la lista invertida, y comparar la secuencia palindrómica

ListNode left = head;
ListNode right = reverse(slow); //reverse函数返回反转后的头结点，就是right位置

while(right != null){ // 比较回文串，right指针的终点是null
	if(left.val != right.val)
		return false;   
	left = left.next;
	right = right.next;
}
return true;

la inversión no recursivo, una reversión a un nodo

ListNode reverse(ListNode head){
	ListNode pre = null, cur = head;
	while(cur != null){
		ListNode next = cur.next;
		cur.next = pre;
		pre = cur;
		cur = next;
	}
	return pre;
}

4. Puede retener la estructura de la cadena original de la entrada de
   clave se obtiene p, q tanto posición de la mano
   justo antes del retorno de la función más uno código Hash para restablecer el orden original de la lista: p.next = inversa (q);