2. Los dos números (aplicación Java)
Título : Dados dos lista no vacía se utiliza para representar dos no negativo entero. Entre ellos, de acuerdo con su respectiva mediana es la inversa de la forma en almacenamiento, y que cada nodo puede almacenar solamente un dígito.
Si sumamos estos dos números, devolverá una nueva lista y para representarlos.
Se puede suponer que, además de los números 0, estos dos números no comenzarán con 0.
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807
Refrescar la idea después de ver los peces gordos de Código
ideas:
- Las dos listas son los mismos que la longitud del recorrido, si una lista es más corta en la parte delantera de relleno 0, por ejemplo: 987 + 23 = 987 + 023 = 1010
- Al mismo tiempo todas las necesidades de computación para examinar la cuestión en un acarreo, pero también es necesario para actualizar el valor actual después del final de la computación de transporte bits
- Si las dos listas de todo el recorrido es completa, el valor de acarreo es 1, a la cabeza de la lista para añadir el nuevo nodo 1. Aquí de explicar, porque terminas resultado se basa en la lista poco a poco a cambio, por lo que independientemente de la mitad la cantidad que llevas, estos llevan se añade a la lista en el cálculo hasta que el último si hay un acarreo, entonces tendríamos nueva insertar un nodo (val = 1).
- La última estructura regresó lista de resultados. Que el blanco es la lista de operaciones en Java, este paso debe ser una comprensión profunda del problema: los objetos de referencia de Java en el objeto . Si eso no es clara, ver los objetos y las referencias que hablan en Java . En términos simples, primero creamos un objeto de encabezado, dos referencias de la cabeza, el punto temporal en la cabeza. A continuación, la cabeza no se mueve, la gente temporales como una herramienta para vincular el nuevo objeto (nodo) (= el temp.next newNode;) , entonces la cola de la lista enlazada puntos de nodo * (temp = temp.next;) * . cabeza de lista de puntos de la cabeza se ha utilizado para devolver los resultados. ( Nota: Puesto que el nodo de cabeza no es una parte del resultado, devuelve head.next )
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
//创建一个头结点对象
ListNode head = new ListNode(0);
//两个引用head和temp都指向这个对象，head用来指向链表头，temp是工具人(有点像C语言中移动的指针)
ListNode temp = head;
//进位标志carry
int carry = 0;
//每一位的求和sum
int sum =0;
while(l1!=null||l2!=null){
int x = null==l1?0:l1.val;
int y = null==l2?0:l2.val;
sum = x+y+carry;
//计算本位是否有进位
carry = sum/10;
//插入本位的计算结果
ListNode newNode = new ListNode(sum%10);
//将新结点插入到链表中
temp.next=newNode;
//指针移动，temp一直指向链表的尾部
temp = temp.next;
if(l1 != null)
l1 = l1.next;
if(l2 != null)
l2 = l2.next;
}
//最高位如果有进位，则插入一个新结点(val=1)
if(carry>0){
temp.next = new ListNode(carry);
}
//head指向的头结点不是结果的一部分，真正的返回结果从head.next开始
return head.next;
}
}
- resultados:
- Creo que mucha gente como yo viendo head.next siente muy infeliz, ¿por qué debería un nodo principal inútil, quiero que mi lista es el resultado, otra vez no eliminar un nodo principal. Por lo tanto, ligeramente modificado el código un poco para resolver los problemas anteriores, es realmente muy simple, añadir un juez en la línea.
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode head = null;
ListNode temp = null;
//进位标志carry
int carry = 0;
//每一位的求和sum
int sum =0;
while(l1!=null||l2!=null){
int x = null==l1?0:l1.val;
int y = null==l2?0:l2.val;
sum = x+y+carry;
//计算本位是否有进位
carry = sum/10;
//插入本位的计算结果
ListNode newNode = new ListNode(sum%10);
//将新结点插入到链表中
//如果头结点为null，就将head指向新创建的结点
if(head==null){
head = newNode;
temp = head;
}else{
temp.next=newNode;
temp = temp.next;
}
if(l1 != null)
l1 = l1.next;
if(l2 != null)
l2 = l2.next;
}
//最高位如果有进位，则插入一个新结点(val=1)
if(carry>0){
temp.next = new ListNode(carry);
}
//head指向的头结点不是结果的一部分，真正的返回结果从head.next开始
return head.next;
}
}
- resultados:
La idea de mi propia inmadurez del siguiente registro
Ver este tema, el primer pensamiento es, para poner las dos listas L1 y L2 de entrada al número entero, que se obtiene mediante la adición de los resultados, a continuación, los resultados devueltos en la lista. (Formas tan estúpida Se nota que el nivel del algoritmo ... por lo general no trabajan duro, que codifica solamente triste ... así que será bueno para golpear el código ah!)
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
StringBuilder str1 = new StringBuilder();
StringBuilder str2 = new StringBuilder();
//遍历l1链表，存储到str1中
while(l1!=null){
str1.append(l1.val);
l1=l1.next;
}
//遍历l2链表，存储到str2中
while(l2!=null){
str2.append(l2.val);
l2=l2.next;
}
try{
//将l1、l2中字符串逆序后准成int类型
int r1 = Integer.parseInt(str1.reverse().toString());
int r2 = Integer.parseInt(str2.reverse().toString());
//求和得到结果
int r = r1+r2;
// System.out.println(r1+" + "+r2+"="+" "+r);
//将结果r从低位到高位插入到结果链表中
ListNode head = null;
if(r==0){
return new ListNode(0);
}
while(r!=0){
ListNode newNode = new ListNode(r%10);
if(head ==null) {
head = newNode;
}else {
ListNode tmp = head;
while(tmp.next!=null) {
tmp = tmp.next;
}
tmp.next = newNode;
}
r = r/10;
}
return head;
}catch(Exception e){
}
return null;
}
}
- Resultados:
hay un problema: con el resultado del cálculo almacenado tipo int, pero el valor es mucho mayor que el intervalo de ensayo del tipo int puede ser representado. He leído algunos mensajes dijeron larga no funciona, el uso BigDecimal a través.
