Ejercicios Prácticos con Listas Enlazadas y Historial de Navegador

Comparto mi solución para el problema 1 Donde podemos hacer sumas con **listas enlazadas de diferentes tamaños**  ```python class Nodo: def __init__(self, valor, siguiente=None, anterior = None): self.valor = valor self.siguiente = siguiente ``````python class ListaEnlazada: def __init__(self, primer_nodo): self.cabeza = primer_nodo self.cola = primer_nodo def insertar_nodo_al_final(self, nuevo_nodo): """ Agrega un nodo al final de la lista """ self.cola.siguiente = nuevo_nodo self.cola = nuevo_nodo def imprimir(self, nodo = None): if nodo is None: nodo = self.cabeza actual = nodo while actual: print(actual.valor, end=" -> ") actual = actual.siguiente print("None") ``````python def suma(lista_1, lista_2): nodo_1 = lista_1.cabeza nodo_2 = lista_2.cabeza lista_3 = ListaEnlazada(Nodo(0)) nodo_3 = lista_3.cabeza suma = 0 A = nodo_1.valor B = nodo_2.valor while nodo_1 or nodo_2: A = A + suma suma = 0 if (A + B) < 10: nodo_3 = Nodo(A+B) else: suma = 1 nodo_3 = Nodo(A+B-10) lista_3.insertar_nodo_al_final(nodo_3) if nodo_1.siguiente is None and nodo_2.siguiente is None: if suma == 0: break else: nodo_3 = Nodo(1) lista_3.insertar_nodo_al_final(nodo_3) break if nodo_1.siguiente: nodo_1 = nodo_1.siguiente A = nodo_1.valor else: A = 0 if nodo_2.siguiente: nodo_2 = nodo_2.siguiente B = nodo_2.valor else: B = 0 cabeza = lista_3.cabeza cabeza_siguiente = cabeza.siguiente cabeza.siguiente = None lista_3.cabeza = cabeza_siguiente return lista_3 ``````python def crear_lista_enlazada(valores: list): nodo1 = Nodo(1) lista = ListaEnlazada(nodo1) for i in valores: lista.insertar_nodo_al_final(Nodo(i)) cabeza = lista.cabeza cabeza_siguiente = cabeza.siguiente cabeza.siguiente = None lista.cabeza = cabeza_siguiente lista.imprimir() return lista ```

```python def rever_sum(l1: Node, l2: Node) -> Lista: # Revertir las listas enlazadas l1.reverse() l2.reverse() # Inicializar variables para la suma y el acarreo carry = 0 result = Lista() # Sumar los nodos correspondientes de las dos listas current_l1 = l1.head current_l2 = l2.head while current_l1 or current_l2 or carry: value = carry if current_l1: value += current_l1.data current_l1 = current_l1.next if current_l2: value += current_l2.data current_l2 = current_l2.next # Calcular el dígito y el nuevo acarreo digit = value % 10 carry = value // 10 # Agregar el dígito al resultado result.append(digit) # Revertir el resultado para obtener la suma correcta result.reverse() return result ```def rever\_sum(l1: Node, l2: Node) -> Lista:    # Revertir las listas enlazadas    l1.reverse()    l2.reverse()     # Inicializar variables para la suma y el acarreo    carry = 0    result = Lista()     # Sumar los nodos correspondientes de las dos listas    current\_l1 = l1.head    current\_l2 = l2.head    while current\_l1 or current\_l2 or carry:        value = carry        if current\_l1:            value += current\_l1.data            current\_l1 = current\_l1.next        if current\_l2:            value += current\_l2.data            current\_l2 = current\_l2.next         # Calcular el dígito y el nuevo acarreo        digit = value % 10        carry = value // 10         # Agregar el dígito al resultado        result.append(digit)     # Revertir el resultado para obtener la suma correcta    result.reverse()     return result

```python def rever_sum(l1:Node, l2:Node): """243 + 564 = 807""" ## returne both lists current = l1.head current_l2 = l2.head while current and current_l2: current = current.next current_l2 = current_l2.next prev = None prev_l2 = None while current and current_l2: current.next, current, prev = prev, current.next, current current_l2.next, current_l2, prev_l2 = prev_l2, current_l2.next, current_l2 curent = prev current_l2 = prev_l2 ## get the data as string and the get in to number result = [] result_l2 = [] current = l1.head current_l2 = l2.head while current and current_l2: result_l2.append(str(current_l2)) result.append(str(current)) current, current_l2 = current.next, current_l2.next suma = int(''.join(result))+int(''.join(result_l2)) return suma ```Aquí mi solución del primero

Buenos los ejercicios. En el primera es aplicar la propiedad conmutativa. En el segundo era muy similar al de pares del módulo. En último, del historial realmente la solución óptima es con listas no con double linked list.
.
Aquí el del historial con linked list, pues ayuda entender mejor: