Sword fait référence à l'offre25 Fusionner deux listes chaînées ordonnées

Annuaire d'articles

Méthode 1 : récursivité

Idée : nous pouvons définir de manière récursive l'opération de fusion dans deux listes chaînées comme suit (en ignorant les cas extrêmes, tels que les listes chaînées vides, etc.) : {
$\left\{\begin{array}{ll} \operatorname{list} 1 [0]+ \operatorname{merge}(\text { liste } 1[1:], \text { liste } 2) & \text { liste } 1[0]<\operatorname{list} 2[0] \\ \text { liste } 2[0]+\text { fusionner }(\text { liste } 1, \text { liste } 2[1:]) & \text { sinon } \end{array}\right.$
C'est-à-dire que le nœud avec la plus petite valeur de tête des deux listes chaînées est fusionné avec le résultat de l'opération de fusion des éléments restants.

algorithme

Nous modélisons directement le processus récursif ci-dessus et nous devons considérer les cas limites.

Si l1 ou l2 est une liste chaînée vide depuis le début, alors aucune opération n'a besoin d'être fusionnée, il suffit de renvoyer une liste chaînée non vide. Sinon, nous devons déterminer quel nœud principal de la liste chaînée a une valeur plus petite, l1 ou l2, puis déterminer de manière récursive le nœud suivant à ajouter au résultat. Si l'une des deux listes chaînées est vide, la récursion se termine.

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;
        }
    }
}

Le code de la méthode récursive est très lisible et facile à retenir et à comprendre.

Méthode 2 : itération

Idée : nous pouvons utiliser des méthodes itératives pour implémenter l'algorithme ci-dessus. Lorsque ni l1 ni l2 ne sont une liste chaînée vide, déterminez quel nœud principal de la liste chaînée a une valeur plus petite et ajoutez le nœud avec la valeur la plus petite au résultat. Lorsqu'un nœud est ajouté au résultat, la liste chaînée correspondante Le nœud dans est déplacé d’une position vers l’arrière.

algorithme

1. Nous définissons un pré-en-tête de nœud sentinelle, qui nous permet de renvoyer plus facilement la liste chaînée fusionnée à la fin.

2. Nous conservons un pointeur précédent et nous devons ajuster son pointeur suivant. Ensuite, nous répétons le processus suivant jusqu'à ce que l1 ou l2 pointe vers null :

Si la valeur du nœud actuel de l1 est inférieure ou égale à l2, nous connectons le nœud actuel de l1 à l'arrière du nœud précédent et déplaçons le pointeur l1 d'une position vers l'arrière. Sinon, on fait la même chose pour l2. Quel que soit l'élément que nous connectons à l'arrière, nous devons reculer le précédent.

Lorsque la boucle se termine, au moins l’un des l1 et l2 n’est pas vide. Étant donné que les deux listes chaînées d'entrée sont toutes deux ordonnées, quelle que soit la liste chaînée qui n'est pas vide, tous les éléments qu'elle contient sont plus arrondis que toutes les listes chaînées précédemment fusionnées. Cela signifie que nous ajoutons simplement la liste chaînée non vide à la liste fusionnée et renvoyons la liste fusionnée.

les références

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