Algoritmo LeetCode 2. Suma dos números

Algoritmo: suma dos números

Se dan dos listas enlazadas no vacías para representar dos enteros no negativos. Entre ellos, sus respectivos dígitos se almacenan en orden inverso, y cada nodo solo puede almacenar un dígito.

Si sumamos estos dos números, se devolverá una nueva lista vinculada para representar su suma.
Puede asumir que, a excepción del número 0, ninguno de estos números comenzará con 0.

Primero entendamos el tipo de datos ListNode. ListNode es un objeto de lista enlazada en Java definido por sí mismo

class ListNode {
    
            //类名 ：Java类就是一种自定义的数据结构
    int val;            //数据 ：当前节点数据 
    ListNode next;      //对象 ：引用下一个节点对象。在Java中没有指针的概念，Java中的引用和C语言的指针类似
    
    ListNode(int val){
    
      //构造方法 ：构造方法和类名相同   
        this.val=val;     //把接收的参数赋值给当前类的val变量
    }
}

Nota: cada nodo tiene un valor val

Ideas de preguntas:
1. Primero juzgue si las dos listas enlazadas están vacías al mismo tiempo, si están vacías, no se realizan más cálculos y regresa directamente.
2. Establezca un nodo principal y lleve el valor addOne cuando no esté vacío.
3. Agregue el primer nodo de los dos ListNodes,% 10 toma el número restante como el valor de un solo dígito, / 10 toma su número entero como el valor de acarreo y el puntero principal se mueve hacia atrás para apuntar al valor de un solo dígito.
4. El puntero de cabeza continúa moviéndose hacia atrás para apuntar al siguiente bit. Cuando l1 y l2 no están vacíos, también continúa moviéndose hacia atrás y ejecutando el bucle.
5. El cálculo se detiene cuando tanto l1 como l2 están vacíos y addOne es 0.
6. Devolver dummy.next hace referencia al puntero de la primera posición de la lista vinculada, de modo que la lista vinculada se pueda buscar más tarde

        public  ListNode addTwoNumbers(ListNode l1,ListNode l2){
    
    
            //判断l1,l2是否同时为空
            if(l1 == null && l2 ==null){
    
    
                return null;
            }
            //定义进一位的变量addOne，初始为0
            int addOne = 0;
            //定义头指针
            ListNode dummy = new ListNode(0);
            ListNode head = dummy;
            //循环遍历条件l1不为null，l2不为null，addOne为0
            while (l1 != null || l2 != null || addOne !=0){
    
    
                //取末尾元素的值
               int val1 = l1 == null ? 0 : l1.val;
               int val2 = l2 == null ? 0 : l2.val;
               //相加
               int sum = val1 + val2 + addOne;
               //取余，确定相加首位置的值
               head.next = new ListNode(sum % 10);
               //head指针后移
               head = head.next;
               //取整，确定进位值
               addOne = sum / 10;
               // l1、l2指针后移
               if(l1 != null) l1 = l1.next;
               if(l2 != null) l2 = l2.next;
            }
            return dummy.next;
        }

Nota: La variable ficticia está configurada para registrar el valor del nodo actual y la cabeza debe mover el puntero hacia atrás.
El proceso de prueba es el siguiente:

    public static class ListNode {
    
    
        int val;
        ListNode next;

        public ListNode(int x) {
    
    
            val = x;
        }

        public static String print(ListNode l) {
    
    
            StringBuilder sb = new StringBuilder();
            while (l != null) {
    
    
                sb.append(l.val);
                l = l.next;
            }
            return sb.toString();
        }
    }
    public static void main(String[] args) {
    
    
        ListNode l1 = new ListNode(2);
        ListNode l2 = new ListNode(5);
        l1.next = new ListNode(4);
        l2.next = new ListNode(6);
        System.out.println(ListNode.print(addTwoNumbers(l1,l2)));


    }

Nota: Dummy es el nodo principal cuyo valor está vacío. El siguiente nodo de dummy es la lista vinculada recién creada y la primera posición, que es el tipo ListNode (puntero). Luego, el puntero que conoce la primera posición puede continuar atravesando la tabla y generar el resultado. El proceso es el siguiente El código anterior.