21. Merge Two Sorted Lists

Author: SlicedPotatoes

Probleme/0021. Merge Two Sorted Lists/imgs/img1.jpg

@@ -0,0 +1,61 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution
+{
+  public:
+    ListNode *mergeTwoLists(ListNode *list1, ListNode *list2)
+    {
+        // Vérifier si l'une des listes est vide, dans ce cas, retourner l'autre liste car elle est déjà triée.
+        if (!list2)
+        {
+            return list1;
+        }
+        if (!list1)
+        {
+            return list2;
+        }
+
+        // Initialiser la tête de la liste fusionnée (une nouvelle liste) et un pointeur pour parcourir cette liste.
+        ListNode *mergedListHead = new ListNode(); // Création du premier élément fictif.
+        ListNode *currentML = mergedListHead;
+
+        // Parcourir les deux listes tant qu'il y a des éléments dans les deux.
+        while (list1 && list2)
+        {
+            // Comparer les valeurs des noeuds actuels des deux listes et insérer le plus petit dans la liste fusionnée.
+            if (list1->val <= list2->val)
+            {
+                currentML->next = list1;
+                list1 = list1->next; // Avancer dans la liste 1.
+            }
+            else
+            {
+                currentML->next = list2;
+                list2 = list2->next; // Avancer dans la liste 2.
+            }
+            currentML = currentML->next; // Avancer dans la liste fusionnée.
+        }
+
+        // Une fois qu'une des listes est entièrement parcourue, il reste à attacher le reste de l'autre liste à la
+        // liste fusionnée.
+        if (list1)
+        {
+            currentML->next = list1;
+        }
+        else if (list2)
+        {
+            currentML->next = list2;
+        }
+
+        // Retourner la tête de la liste fusionnée (en sautant le premier élément fictif).
+        return mergedListHead->next;
+    }
+};

Probleme/0021. Merge Two Sorted Lists/imgs/memory.png

@@ -0,0 +1,90 @@
+# 21. Merge Two Sorted Lists
+
+## Énoncé
+
+Vous recevez les têtes de deux listes chaînées triées `list1` et `list2`.
+
+Fusionnez les deux listes en une seule liste **triée**. La liste doit être établie en réunissant les nœuds des deux premières listes.
+
+Renvoie la tête de la liste chaînée fusionnée.
+
+## Exemple
+
+**Exemple 1:**
+
+<img src="./imgs/img1.jpg"/>
+
+**Input:** list1 = [1,2,4], list2 = [1,3,4]  
+**Output:** [1,1,2,3,4,4]
+
+**Exemple 2:**  
+**Input:** list1 = [], list2 = []  
+**Output:** []
+
+**Exemple 3:**  
+**Input:** list1 = [], list2 = [0]  
+**Output:** [0]
+
+## Contraintes
+
+Le nombre de nœuds dans les deux listes est compris entre `[0, 50]`.  
+`-100 <= Node.val <= 100`  
+`list1` et `list2` sont triés par ordre croissant.
+
+## Note personnelle
+
+Ma méthode implique la création d'une nouvelle liste nommée `margedListHead` et de son pointeur d'élément courant `currentML`. Ensuite, je parcours les deux listes simultanément tant qu'elles contiennent des éléments. À chaque itération, j'effectue les actions suivantes :
+
+- Je compare les valeurs de `list1` et `list2`. Si `list1->val <= list2->val`, alors je mets à jour `currentML->next` avec le pointeur `list1` et je progresse dans `list1` de 1.
+- Sinon, je fais la même chose avec `list2`
+- Ensuite, j'avance de 1 dans `currentML`.
+
+À la sortie de la boucle, je vérifie si l'une des deux listes n'est pas vide pour l'ajouter à la fin de `currentML`.
+
+J'ai également implémenté une approche récursive de ce problème qui suit le même principe que la version itérative. Les deux approches présentent une complexité temporelle de `O(n)` et une complexité spatiale de `O(1)`.
+
+```cpp
+ListNode * merged = new ListNode();
+class Solution {
+public:
+  ListNode* mergeTwoLists(ListNode* list1, ListNode* list2, ListNode * currentMerged = merged) {
+    // Si les deux listes sont vides
+    if(!list1 && !list2){
+      return nullptr;
+    }
+
+    if(!list1){
+      // Si list1 est vide, attache directement list2 à la fin du noeud fusionné
+      currentMerged->next = list2;
+      // Retourne le début de la liste fusionnée
+      return merged->next;
+    }
+    if(!list2){
+      // Si list2 est vide, attache directement list1 à la fin du noeud fusionné
+      currentMerged->next = list1;
+      // Retourne le début de la liste fusionnée
+      return merged->next;
+    }
+
+    // Si la valeur du noeud de list1 est inférieure ou égale à celle du noeud de list2
+    if(list1->val <= list2->val){
+      // Attache le noeud de list1 à la liste fusionnée
+      currentMerged->next = list1;
+      // Avance le pointeur de list1 au noeud suivant
+      list1 = list1->next;
+    }
+    else{
+      // Sinon, attache le noeud de list2 à la liste fusionnée
+      currentMerged->next = list2;
+      // Avance le pointeur de list2 au noeud suivant
+      list2 = list2->next;
+    }
+
+    // Appel récursif pour continuer la fusion des listes
+    return mergeTwoLists(list1, list2, currentMerged->next);
+  }
+};
+```
+
+<img src="./imgs/runtime.png"/>
+<img src="./imgs/memory.png"/>

Probleme/0021. Merge Two Sorted Lists/imgs/runtime.png

@@ -11,6 +11,7 @@ Une liste chaînée, composée de trois éléments ayant respectivement la valeu
 
 | Label                                                                                    | Tags                                                                                                                                | Date       |
 | ---------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------- |
+| [21. Merge Two Sorted Lists](../Probleme/0021.%20Merge%20Two%20Sorted%20Lists/)          | [`Linked List`](./linked_list.md), [`Recursion`](./recursion.md)                                                                    | 15-03-2024 |
 | [141. Linked List Cycle](../Probleme/0141.%20Linked%20List%20Cycle/)                     | [`Hash Table`](./hash_table.md), [`Linked List`](./linked_list.md), [`Two Pointers`](./two_pointers.md)                             | 06-03-2024 |
 | [206. Reverse Linked List](../Probleme/0206.%20Reverse%20Linked%20List/)                 | [`Linked List`](./linked_list.md), [`Recursion`](./recursion.md)                                                                    | 09-03-2024 |
 | [706. Design HashMap](../Probleme/0706.%20Design%20HashMap/)                             | [`Array`](./array.md), [`Hash Table`](./hash_table.md), [`Linked List`](./linked_list.md), [`Design`](./design.md), `Hash Function` | 09-03-2024 |

Probleme/0021. Merge Two Sorted Lists/main.cpp

@@ -6,10 +6,11 @@ la **Recursion** est un concept où une fonction s'appelle elle-même pour réso
 
 ### Facile
 
-| Label                                                                    | Tags                                                                                                                    | Date       |
-| ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------- | ---------- |
-| [206. Reverse Linked List](../Probleme/0206.%20Reverse%20Linked%20List/) | [`Linked List`](./linked_list.md), [`Recursion`](./recursion.md)                                                        | 09-03-2024 |
-| [509. Fibonacci Number](../Probleme/0509.%20Fibonacci%20Number/)         | [`Math`](./math.md), [`Dynamic Programming`](./dp.md), [`Memoization`](./memoization.md), [`Recursion`](./recursion.md) | 08-03-2024 |
+| Label                                                                           | Tags                                                                                                                    | Date       |
+| ------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ---------- |
+| [21. Merge Two Sorted Lists](../Probleme/0021.%20Merge%20Two%20Sorted%20Lists/) | [`Linked List`](./linked_list.md), [`Recursion`](./recursion.md)                                                        | 15-03-2024 |
+| [206. Reverse Linked List](../Probleme/0206.%20Reverse%20Linked%20List/)        | [`Linked List`](./linked_list.md), [`Recursion`](./recursion.md)                                                        | 09-03-2024 |
+| [509. Fibonacci Number](../Probleme/0509.%20Fibonacci%20Number/)                | [`Math`](./math.md), [`Dynamic Programming`](./dp.md), [`Memoization`](./memoization.md), [`Recursion`](./recursion.md) | 08-03-2024 |
 
 ### Moyen