Leetcode 21. Dos métodos para fusionar dos listas enlazadas ordenadas C lenguaje 100%

【Título】

Combine las dos listas vinculadas ascendentes en una nueva lista vinculada ascendente y regrese. La nueva lista vinculada se compone de todos los nodos de las dos listas vinculadas dadas. 

Ejemplos:

Entrada: 1-> 2-> 4, 1-> 3-> 4
Salida: 1-> 1-> 2-> 3-> 4-> 4

【Pensamiento】

Hay dos ideas, una de las cuales se implementa a través de la recursividad.

La ecuación recursiva es

1  {
 2       l1 [ 0 ] + fusión (l1-> siguiente, l2) l1 < l2
 3       l2 [ 0 ] + fusión (l1, l2-> siguiente) l2 < l1  
 4 }

Primero compare el tamaño del primer número de las dos listas enlazadas, seleccione la más pequeña y luego conecte la secuencia recursiva.

【Código】

 

1  / * *
 2  * Definición de lista individualmente vinculada.
3  * struct ListNode {
 4  * int val;
5  * struct ListNode * next;
6  *};
7   * / 
8  
9  
10  struct ListNode * mergeTwoLists ( struct ListNode * l1, struct ListNode * l2) {
 11      if (! L1)
 12          return l2;
13      más  si (! L2)
 14          devuelve l1;
15      más {
 16         if (l1-> val <l2-> val) {
 17              l1-> next = mergeTwoLists (l1-> next, l2);
18              regreso l1;
19          }
 20          más {
 21              l2-> siguiente = mergeTwoLists (l1, l2-> siguiente);
22              retorno l2;
23          }
 24      }
 25 }

Primero defina la condición de recursión, cuando l1 o l2 está vacío, devuelva otra lista vinculada no vacía.

Luego, para ambos no vacíos, compare el tamaño de l1 l2, elija una cabeza más pequeña para conectar la secuencia reorganizada y regrese a la cabeza

【Resultado】

0ms 100%

5.6MB 100%

 

【Pensamiento】

Procesamiento iterativo

Primero construya una cabeza de cadena, y finalmente úsela como puntero cuando regrese.

Además, para simplificar la operación, en lugar de extraer cada cadena y conectarla al cabezal de la cadena, puede apuntar directamente el cabezal de la cadena a l1 o l2, de modo que si desea conectar varias cadenas en la misma cadena a la vez, u otra lista esté vacía En este momento, no se requieren operaciones adicionales.

Además, como el final de la tabla ordenada final, se debe establecer un puntero para conectar las dos tablas.

【Código】

1  / * *
 2  * Definición de lista individualmente vinculada.
3  * struct ListNode {
 4  * int val;
5  * struct ListNode * next;
6  *};
7   * / 
8  
9  
10  struct ListNode * mergeTwoLists ( struct ListNode * l1, struct ListNode * l2) {
 11      if (! L1)
 12          return l2;
13      más  si (! L2)
 14          devuelve l1;
15      struct ListNode * pre, *norte;
16      pre = ( struct ListNode *) malloc ( sizeof ( struct ListNode)); //
 17      pre> val = - 1 ;
18      n = pre;
19      while (l1 && l2) { // 
20          if (l1-> val> = l2-> val) {
 21              n-> next = l2; 
22              l2 = l2-> siguiente;
23              n = n-> siguiente;
24          }
 25          más {
 26              n-> siguiente =l1;
27              l1 = l1-> siguiente;
28              n = n-> siguiente;
29          }
 30      }
 31      if (l1) //
 32          n-> next = l1;
33      más 
34          n-> siguiente = l2;
35      volver pre> siguiente;
36      
37 }

[Análisis de error]

En realidad olvidé la línea 31-34

¡La condición para salir en bucle es que ni l1 ni l2 están vacíos, cuando sale el último salto! Debe haber una tabla cuya última es relativamente pequeña, y luego llega al final, ¡la última n no debe estar conectada a otra tabla! ¡Así que asegúrese de lidiar con la cola al final!