Sword se refiere a la oferta 25 Fusionar dos listas enlazadas ordenadas

Directorio de artículos

Método 1: recursividad

Idea: Podemos definir de forma recursiva la operación de combinación en dos listas enlazadas de la siguiente manera (ignorando los casos extremos, como listas enlazadas vacías, etc.): {
$\left\{\begin{array}{ll} \operatorname{lista} 1 [0]+ \operatorname{merge}(\text { lista } 1[1:], \text { lista } 2) & \text { lista } 1[0]<\operatorname{lista} 2[0] \\ \text { lista } 2[0]+\text { merge }(\text { lista } 1, \text { lista } 2[1:]) & \text { de lo contrario } \end{array}\right.$
Es decir, el nodo con el valor principal más pequeño de las dos listas vinculadas se fusiona con el resultado de la operación de fusión de los elementos restantes.

algoritmo

Modelamos directamente el proceso recursivo anterior y debemos considerar casos límite.

Si l1 o l2 son una lista vinculada vacía desde el principio, entonces no es necesario fusionar ninguna operación, solo necesitamos devolver una lista vinculada no vacía. De lo contrario, tenemos que determinar qué nodo principal de la lista vinculada tiene un valor menor, l1 o l2, y luego determinar de forma recursiva el siguiente nodo para agregar al resultado. Si una de las dos listas enlazadas está vacía, la recursividad finaliza.

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        } else if (l2 == null) {
            return l1;
        } else if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

El código del método recursivo es muy legible y fácil de recordar y comprender.

Método 2: iteración

Idea: podemos utilizar métodos iterativos para implementar el algoritmo anterior. Cuando ni l1 ni l2 son una lista vinculada vacía, determine qué nodo principal de la lista vinculada tiene un valor menor y agregue el nodo con el valor más pequeño al resultado. Cuando se agrega un nodo al resultado, la lista vinculada correspondiente El nodo en se mueve una posición hacia atrás.

algoritmo

1. Configuramos un preencabezado de nodo centinela, que nos permite devolver la lista enlazada fusionada más fácilmente al final.

2. Mantenemos un puntero anterior y lo que debemos hacer es ajustar su puntero siguiente. Luego, repetimos el siguiente proceso hasta que l1 o l2 apunte a nulo:

Si el valor del nodo actual de l1 es menor o igual a l2, conectamos el nodo actual de l1 a la parte posterior del nodo anterior y movemos el puntero l1 una posición hacia atrás. De lo contrario, hacemos lo mismo para l2. No importa qué elemento conectemos a la parte posterior, debemos mover el anterior hacia atrás.

Cuando el ciclo termina, al menos uno de l1 y l2 no está vacío. Dado que las dos listas vinculadas de entrada están ordenadas, no importa qué lista vinculada no esté vacía, todos los elementos que contiene están más redondeados que todas las listas vinculadas fusionadas previamente. Esto significa que simplemente agregamos la lista vinculada no vacía a la lista fusionada y devolvemos la lista fusionada.

referencias

[1] https://leetcode.cn/problems/merge-two-sorted-lists/solution/he-bing-liang-ge-you-xu-lian-biao-by-leetcode-solu/