Se le dan dos listas enlazadas no vacías que representan dos enteros no negativos. Cada uno de sus dígitos se almacena en orden inverso, y cada nodo solo puede almacenar un dígito.
Agregue dos números y devuelva una lista vinculada que represente la suma en el mismo formulario.
Puedes suponer que ningún número comienza con un cero que no sea el número cero.
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
Este es un problema de lista enlazada muy clásico, que se puede resolver mediante una suma analógica. Específicamente, podemos mantener un acarreo variable que represente el acarreo, y luego agregar los nodos correspondientes en las dos listas vinculadas y agregar el acarreo acarreo. El resultado final es el número en la posición actual. Si excede 10, entonces necesitamos Acarreo se establece en 1, de lo contrario se establece en 0.
Los pasos específicos de la operación son los siguientes:
1. Primero defina un nodo vacío ficticio y un puntero p, que representan el nodo principal y el nodo actual de la lista enlazada de resultados.
2. Defina dos punteros p1 y p2 para que apunten a los nodos principales de las dos listas vinculadas respectivamente, y luego muévalos hasta que una de las listas vinculadas esté vacía.
3. En el ciclo, primero calcule el número en la posición actual, luego cree un nuevo nodo para almacenar este número y agréguelo al final de la lista de resultados. Al mismo tiempo, actualice el valor de acarreo.
4. Si se ha atravesado una lista enlazada, entonces debemos agregar la parte restante de otra lista enlazada y llevarla a la lista enlazada de resultados a su vez.
5. Finalmente, regrese al siguiente nodo del dummy.
El código se implementa de la siguiente manera:
package com.example.算法;
public class ListNode1 {
public static void main(String[] args) {
//创建两个链表l1和l2（此处省略创建过程）
ListNode1 l1 = new ListNode1(2, new ListNode1(4, new ListNode1(3)));
ListNode1 l2 = new ListNode1(5, new ListNode1(6, new ListNode1(4)));
//调用addTwoNumbers函数计算结果
ListNode1 result = addTwoNumbers(l1, l2);
//遍历并输出新链表中的每个节点值
while (result != null) {
System.out.print(result.val + " ");
result = result.next;
}
}
int val;
ListNode1 next;
ListNode1() {
}
ListNode1(int val) {
this.val = val;
}
ListNode1(int val, ListNode1 next) {
this.val = val;
this.next = next;
}
public static ListNode1 addTwoNumbers(ListNode1 l1, ListNode1 l2) {
ListNode1 dummy = new ListNode1(0); // 这里需要用到哑结点技巧
ListNode1 tail = dummy; // 定义一个尾指针，用于构建答案链表
int carry = 0; // 进位信息，初始值为0
while (l1 != null || l2 != null) {
int x = (l1 != null) ? l1.val : 0;
int y = (l2 != null) ? l2.val : 0;
int sum = carry + x + y;
carry = sum / 10; // 更新进位信息
tail.next = new ListNode1(sum % 10); // 构造答案链表的下一个节点
tail = tail.next; // 将尾指针向后移动一位
if (l1 != null) {
l1 = l1.next;
}
if (l2 != null) {
l2 = l2.next;
}
}
if (carry > 0) {
tail.next = new ListNode1(carry); // 处理最高位的进位
}
return dummy.next; // 返回哑结点的下一个节点，即为所求的答案链表
}
}
método común
package com.example.算法;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import static java.util.Collections.replaceAll;
public class ListNode {
public static void main(String[] args) {
final int l1 = 9999999;
final int l2 = 9999;
int carry = 0;
String a = new Demo().lee(l1, l2);
System.out.println("------------------------------------");
String a2 = new Demo().lee3(l1, l2);
System.out.println("------------------------------------");
Double aa = 1003.0;
aa = aa / 10;
System.out.println(aa);
int abc = aa.intValue();
System.out.println(abc);
}
}
class Demo {
public String lee(int l1, int l2) {
int num = l1 + l2;
// 反转后的数字
int reverseNum = 0;
// 反向遍历每一位数字
while (num != 0) {
int digit = num % 10; //10的余数可以理解为取最后个位数
// System.out.println("现在的digit代表着个位数" + digit);
reverseNum = reverseNum * 10 + digit; // 将个位数添加到反转数中
num /= 10; // 去掉已处理的最后一位数
}
// 将反转后的数字转换成字符串形式
String nums = Integer.toString(reverseNum);
// 创建一个 StringBuffer 对象，用于拼接结果字符串
StringBuffer sb = new StringBuffer();
for (int i = 0; i < nums.length(); i++) {
//append 拼接字符串 nums.charAt(i) 先拿到其中的每一位
sb.append(nums.charAt(i));
// 如果不是最后一位数字，则在数字之间添加一个逗号
if (i != nums.length() - 1) {
sb.append(",");
}
}
// 将 StringBuffer 对象转换成字符串，并返回结果
String fa = sb.toString();
System.out.println("输出:1[" + fa + "]");
return fa;
}
public String lee3(int l1, int l2) {
int num = l1 + l2;
List<Integer> digits = new ArrayList<>();
// 取出每一位数字并添加到列表中
while (num > 0) {
//余数可以理解为取最后个位数 相当于把数据倒序了下取出来 num%10 取出来个位数 add 给了digits 下面再把已经add的数据删除了
digits.add(num % 10);
//再取消最后一位 把上面num % 10
num /= 10;
}
// 将列表中的数字反转并拼接成字符串
//首先使用stream()方法将整数列表转换为流，然后使用map()方法将每个整数转换为字符串形式。Object::toString
// 表示将每个对象（包括整数）转换为它的字符串表示形式。最后，使用collect()方法与Collectors.joining()静态方法结合使用，
// 使用逗号连接符将所有字符串组合在一起，并返回拼接后的字符串。
String fa = digits.stream()
.map(Object::toString)
.collect(Collectors.joining(","));
System.out.println("输出3:[" + fa + "]");
return fa;
}
}
Esta es una pieza de código Java que implementa principalmente la suma de dos enteros y genera el resultado como una cadena en orden inverso. En el código se utilizan dos métodos diferentes para lograr esto. En el primer método, cada dígito se recorre en sentido inverso a través de las operaciones de resto y división, y se suma al número invertido; en el segundo método, primero se almacenan los números calculados en una lista. , invierta y concatene los números de la lista en una cadena. Finalmente, al llamar al método main(), se puede obtener la salida del programa.
Específicamente, el código contiene las siguientes partes importantes:
Suma de dos números enteros
En el código se definen dos constantes l1 y l2, que representan respectivamente los dos números enteros que se deben sumar. Al sumarlos, obtenemos el valor de num, que es la suma de los dos números.
final int l1 = 9999999;
final int l2 = 9999;
int num = l1 + l2;
Recorrido inverso de cada dígito
Para generar los números en orden inverso, se usa una declaración de ciclo while en el código para recorrer num en reversa. En cada ciclo, obtenga el último dígito de num por módulo 10 y agréguelo a reverseNum. Luego, dividiendo por 10, elimine el último dígito que se ha procesado. Cuando num es igual a 0, significa que todos los números han sido procesados y el ciclo finaliza.
while (num != 0) {
int digit = num % 10;
reverseNum = reverseNum * 10 + digit;
num /= 10;
}
Convierta números en cadenas y salida
En el código, primero convierta el número invertido reverseNum en una forma de cadena nums, luego recorra cada dígito en él, agregue una coma entre los números y agregue el resultado al objeto StringBuffer en el medio. Finalmente, sb se convierte en la cadena fa y se devuelve.
String nums = Integer.toString(reverseNum);
StringBuffer sb = new StringBuffer();
for (int i = 0; i < nums.length(); i++) {
sb.append(nums.charAt(i));
if (i != nums.length() - 1) {
sb.append(",");
}
}
String fa = sb.toString();
System.out.println("输出:1[" + fa + "]");
return fa;
Use operaciones de flujo para invertir números y empalmarlos en cadenas.En
el código se define otro método lee3.En comparación con el método anterior lee, utiliza la nueva operación de flujo en Java8 para lograrlo. Específicamente, el código primero agrega cada dígito del número calculado num a los dígitos de una lista y luego invierte los números en la lista a través de métodos como stream(), map() y collect(), concatenados en una cadena. Finalmente, devuelva la cuerda empalmada fa.
List<Integer> digits = new ArrayList<>();
while (num > 0) {
digits.add(num % 10);
num /= 10;
}
String fa = digits.stream()
.map(Object::toString)
.collect(Collectors.joining(","));
System.out.println("输出3:[" + fa + "]");
return fa;
En general, este código usa dos métodos diferentes para sumar dos enteros y generar el resultado como una cadena en orden inverso. Entre ellos, el método de recorrer cada dígito en reversa a través del resto y las operaciones de división es más intuitivo y fácil de entender, mientras que la implementación usando operaciones de flujo es más concisa y eficiente. Los diferentes métodos tienen sus propias ventajas y escenarios aplicables, y puede elegir según la situación específica.
En el primer método, el código itera a través de cada dígito del entero a través de un bucle while y lo suma a un número invertido. Luego, convierta el número invertido en una cadena e itere sobre cada dígito en él, agregue comas entre los números y genere una cadena.
En el segundo enfoque, el código primero agrega cada dígito del número calculado a una lista, luego usa operaciones de flujo para invertir y concatenar los números en la lista en una cadena.
En general, este código muestra diferentes enfoques en Java para lograr el mismo objetivo y explica sus ventajas y casos de uso.