Dadas dos listas vinculadas, cada nodo de lista con un dígito entero, agregue estas dos listas vinculadas. El resultado debe almacenarse en la tercera lista vinculada. También tenga en cuenta que el nodo principal contiene el dígito más significativo del número.
Solución : dado que la suma de enteros comienza desde el dígito menos significativo, primero debemos visitar el último nodo de ambas listas y sumarlas, crear un nuevo nodo para almacenar el resultado, cuidar el acarreo si lo hay y vincular el resultado nodo a nodo que se agregará al segundo nodo menos significativo y continuará.
En primer lugar, debemos tener en cuenta la diferencia en el número de dígitos en dos números. Entonces, antes de comenzar la recursión, necesitamos hacer algunos cálculos y mover el puntero de la lista más larga al lugar apropiado para que necesitemos el último nodo de ambas listas al mismo tiempo. Otra cosa es que tenemos que cuidar es llevar. Si dos dígitos suman más de 10, debemos reenviar el acarreo al siguiente nodo y agregarlo a ellos. Si la suma de dígitos más significativa resulta en carry, necesitamos crear un nodo adicional para almacenar carry.
- Si U = {todos los enteros positivos menores o iguales a 30} y N = {todos los números impares menores o iguales a 19}, ¿qué es N 'y n (N')?
- Cómo dividir una matriz en 2 nuevas variables de matriz y encontrar el promedio de ellas
- Conozco la implementación básica de diferentes estructuras de datos como árboles, gráficos, colas y muchos más para inserción, eliminación, recorrido. Ahora, ¿cómo procedo a construir un sistema operativo?
- ¿Cuáles son los beneficios del ordenamiento dinámico y sus desventajas en comparación con otros algoritmos de ordenamiento?
- ¿Cómo funciona el algoritmo de Amazon?
La función a continuación es en realidad una función de envoltura que hace todo el mantenimiento como calcular longitudes de listas, llamar a la implementación recursiva, crear un nodo adicional para llevar en el dígito más significativo y agregar los nodos restantes que quedan en la lista más larga.
void addListNumbersWrapper (struct ListNode * list1, struct ListNode * list2, int * carry, struct ListNode ** result) {
int list1Length = 0, list2Length = 0, diff = 0;
struct ListNode * current = list1;
while (actual) {
actual = actual → siguiente;
list1Length ++;
}
actual = lista2;
while (actual) {
actual = actual → siguiente;
list2Length ++;
}
if (list1Length <list2Length) {
actual = lista1;
lista1 = lista2;
lista2 = actual;
}
diff = abs (list1Length-list2Length);
actual = lista1;
mientras (diff–)
actual = actual → siguiente;
addListNumbers (current, list2, carry, result);
diff = abs (list1Length-list2Length);
addRemainingNumbers (list1, carry, result, diff);
if (* carry) {
struct ListNode * temp = (struct ListNode *) malloc (sizeof (struct ListNode));
temp → next = (* resultado);
* resultado = temp;
}
regreso;
}
void addListNumbers (struct ListNode * list1, struct ListNode * list2, int * carry, struct ListNode ** result) {
int sum;
if (! list1)
regreso;
addListNumbers (list1 → next, list2 → next, carry, result);
// Fin de ambas listas, agréguelas
struct ListNode * temp = (struct ListNode *) malloc (sizeof (struct ListNode));
sum = list1 → data + list2 → data + (* carry);
// Tienda llevar
* carry = suma / 10;
suma = suma% 10;
temp → datos = suma;
temp → next = (* resultado);
* resultado = temp;
regreso;
}
void addRemainingNumbers (struct ListNode * list1, int * carry, struct ListNode ** result, int diff) {
int suma = 0;
if (! list1 || diff == 0)
regreso;
addRemainingNumbers (list1 → next, carry, result, diff-1);
struct ListNode * temp = (struct ListNode *) malloc (sizeof (struct ListNode));
sum = list1-> data + (* carry);
* carry = suma / 10;
suma = suma% 10;
temp → datos = suma;
temp → next = (* resultado);
* resultado = temp;
regreso;
}
Complejidad del tiempo: O ().
Complejidad espacial: O () para pila recursiva.
Nota: También se puede resolver con pilas.
