LeetCode — 206 Cpp y Python de lista enlazada inversa

Requisito de la pregunta: Pase el puntero del encabezado de la lista vinculada e invierta la lista vinculada

El proceso es el siguiente:
Entrada: 1-> 2-> 3-> 4-> 5-> NULL
Salida: 5-> 4-> 3-> 2-> 1-> NULL

1. Métodos e ideas

Método 1: método iterativo
En el proceso de recorrer la lista vinculada, haga que el nodo actual apunte al nodo anterior. Además, se necesita otro puntero para almacenar el siguiente nodo y, finalmente, volver al nuevo nodo principal.
El proceso es el siguiente

Al atravesar, complete tres pasos:
Paso 1: El
nodo actual apunta al nodo anterior new_head
Paso 2:
New_head se mueve a la posición de la cabeza Paso
3: La
cabeza se mueve a la siguiente posición, en este proceso, debe introducir el siguiente nodo para guardar la información de posición para completar la operación

---

Método 2: Recursión
La idea de la recursividad es recurrir primero al final, encontrar el último nodo y luego comenzar desde el último nodo y girar la dirección de la flecha.
Texto de marcado
Condiciones finales recursivas:

if(head == NULL || head->next == NULL) 
    return head;

Después de obtener el último nodo, regrese a la capa superior de recursividad, p apunta al último nodo de la lista vinculada original, y ahora debería ser el nodo principal, y la p subsiguiente no necesita ser cambiada, y continúa regresando a la capa superior de recursividad.

Cambie el siguiente punto del encabezado para que apunte a sí mismo, y luego apunte el siguiente al vacío, como el último nodo de la nueva lista vinculada

head->next->next = head;
head->next = NULL;

La recursividad termina y el retorno final es p (nodo principal)

Dos, código C ++

#include <stdio.h>

struct ListNode {
    
    
	int val;
	ListNode *next;
	ListNode(int x) : val(x), next(NULL) {
    
    }
};

class Solution {
    
    
public:
	ListNode* ReverseTheList1(ListNode* head){
    
    //迭代法
		ListNode *new_head = NULL;
		while (head)  //进行遍历
		{
    
    
			ListNode *next = head->next;
			head->next = new_head;
			new_head = head;
			head = next;
		}
		return new_head;
	}
	ListNode* ReverseTheList2(ListNode* head) {
    
    //递归法
		if (head == NULL || head->next == NULL)
			return head;

		ListNode* p = ReverseTheList2(head->next);
		head->next->next = head;
		head->next = NULL;
		return p;
	}
	
};
	int main() {
    
    //测试用例
		ListNode a1(1);ListNode b1(2);ListNode c1(3);ListNode d1(4);ListNode e1(5);
		a1.next = &b1; b1.next = &c1; c1.next = &d1; d1.next = &e1;
		ListNode a2(1); ListNode b2(2); ListNode c2(3); ListNode d2(4); ListNode e2(5);
		a2.next = &b2; b2.next = &c2; c2.next = &d2; d2.next = &e2;
		Solution solve;
		ListNode *head1 = solve.ReverseTheList1(&a1);
		ListNode *head2 = solve.ReverseTheList2(&a2);
		while (head1){
    
    
			printf("%d\n", head1->val);
			head1 = head1->next;
		}
		printf("------------\n");
		while (head2) {
    
    
			printf("%d\n", head2->val);
			head2 = head2->next;
		}
		return 0;
	}
	//Time:O(n) Sapce:O(1)

---

Tres, código Python

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
	#迭代法
    def reverseList1(self, head: ListNode) -> ListNode:
        pre, cur = None, head
        while cur:
            temp = cur.next
            cur.next = pre
            pre, cur = cur, temp
        return pre

	#递归法
     def reverseList(self, head: ListNode) -> ListNode:
        if not head or not head.next:
            return head
        newhead = self.reverseList(head.next)
        head.next.next = head
        head.next = None
        return newhead