update 21

LinkedList/21_MergeTwoSortedLists.cpp

@@ -0,0 +1,74 @@
+/*
+ * @Author: xuezaigds@gmail.com
+ * @Last Modified time: 2016-04-28 11:19:51
+ */
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+
+ // Recursively
+class Solution {
+public:
+    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
+        if(l1==NULL)    return l2;
+        if(l2==NULL)    return l1;
+
+        ListNode *head = NULL;
+        if(l1->val <= l2->val){
+            head = l1;
+            head->next = mergeTwoLists(l1->next, l2);
+        }
+        else{
+            head = l2;
+            head->next = mergeTwoLists(l1, l2->next);
+        }
+        // head point to some node in l1 or l2, so can be returned here.
+        return head;
+    }
+};
+
+ // Iteratively
+class Solution_2 {
+public:
+    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
+        ListNode *pre_head = new ListNode(0);
+        ListNode *cur = pre_head;
+        while(l1!=NULL && l2!=NULL){
+            if(l1->val <= l2->val){
+                cur->next = l1;
+                l1 = l1->next;
+            }
+            else{
+                cur->next = l2;
+                l2 = l2->next;
+            }
+            cur = cur->next;
+        }
+        while(l1!=NULL){
+            cur->next = l1;
+            l1 = l1->next;
+            cur = cur->next;
+        }
+        while(l2!=NULL){
+            cur->next = l2;
+            l2 = l2->next;
+            cur = cur->next;
+        }
+        return pre_head->next;
+    }
+};
+
+/*
+[]
+[]
+[1,4,8,12]
+[2,3]
+[1,3,5,7,9]
+[2,4,6,8,10]
+*/

LinkedList/21_MergeTwoSortedLists.py

@@ -8,42 +8,50 @@
 #         self.next = None
 
 
+# Recursive way.
 class Solution(object):
     def mergeTwoLists(self, l1, l2):
-        """
-        :type l1: ListNode
-        :type l2: ListNode
-        :rtype: ListNode
-        """
-        while not l1 and not l2:
-            return None
+        if not l1:
+            return l2
+        if not l2:
+            return l1
+        merged_head = None
+        if(l1.val <= l2.val):
+            merged_head = l1
+            merged_head.next = self.mergeTwoLists(l1.next, l2)
+        else:
+            merged_head = l2
+            merged_head.next = self.mergeTwoLists(l1, l2.next)
+        return merged_head
 
+
+# Iteratively
+class Solution_2(object):
+    def mergeTwoLists(self, l1, l2):
         merged_list = ListNode(0)
         merged_head = merged_list
 
         # Scan through l1 and l2, get the smaller one to merged list
         while l1 and l2:
             if l1.val <= l2.val:
-                node = ListNode(l1.val)
+                merged_list.next = l1
                 l1 = l1.next
+
             else:
-                node = ListNode(l2.val)
+                merged_list.next = l2
                 l2 = l2.next
-            merged_list.next = node
             merged_list = merged_list.next
 
         # l2 has gone to the tail already and only need to scan l1
         while l1:
-            node = ListNode(l1.val)
+            merged_list.next = l1
             l1 = l1.next
-            merged_list.next = node
             merged_list = merged_list.next
 
         # l1 has gone to the tail already and only need to scan l2
         while l2:
-            node = ListNode(l2.val)
+            merged_list.next = l2
             l2 = l2.next
-            merged_list.next = node
             merged_list = merged_list.next
 
         return merged_head.next