力扣—— 21、23合并链表（两个、K个）

目录

C++

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode temp_head(0);
        ListNode *pre=&temp_head;
        while(l1 && l2){
            if(l1->val<l2->val){
                pre->next=l1;
                l1=l1->next;
            }
            else{
                pre->next=l2;
                l2=l2->next;
            }
            pre=pre->next;
        }
        if(l1){
            pre->next=l1;
        }
        if(l2){
            pre->next=l2;
        }
        return temp_head.next;
    }
};

python

class Solution(object):
    def mergeTwoLists(self, list1, list2):
        """
        :type list1: Optional[ListNode]
        :type list2: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        prehead = ListNode(-1)

        prev = prehead
        while list1 and list2:
            if list1.val <= list2.val:
                prev.next = list1
                list1 = list1.next
            else:
                prev.next = list2
                list2 = list2.next
            prev = prev.next

        prev.next = list1 if list1 is not None else list2
        return prehead.next

递归

class Solution(object):
    def mergeTwoLists(self, list1, list2):
        """
        :type list1: Optional[ListNode]
        :type list2: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        if list1 is None:
            return list2
        elif list2 is None:
            return list1
        elif list1.val < list2.val:
            list1.next = self.mergeTwoLists(list1.next, list2)
            return list1
        else:
            list2.next = self.mergeTwoLists(list1, list2.next)
            return list2

分治合并
C++

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode temp_head(0);
        ListNode *pre=&temp_head;
        while(l1 && l2){
            if(l1->val<l2->val){
                pre->next=l1;
                l1=l1->next;
            }
            else{
                pre->next=l2;
                l2=l2->next;
            }
            pre=pre->next;
        }
        if(l1){
            pre->next=l1;
        }
        if(l2){
            pre->next=l2;
        }
        return temp_head.next;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size() ==0){
            return NULL;
        }
        if (lists.size() ==1){
            return lists[0];
        }
        if (lists.size()==2){
            return mergeTwoLists(lists[0],lists[1]);
        }
        int mid=lists.size()/2;

        std::vector<ListNode*>sub1_lists;
        std::vector<ListNode*>sub2_lists;

        for (int i=0;i<mid;i++){
            sub1_lists.push_back(lists[i]);
        }
        for (int i=mid;i<lists.size();i++){
            sub2_lists.push_back(lists[i]);
        }

        ListNode *l1=mergeKLists(sub1_lists);
        ListNode *l2=mergeKLists(sub2_lists);

        return mergeTwoLists(l1,l2);

    }
};

python

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        prehead = ListNode(-1)

        prev = prehead
        while l1 and l2:
            if l1.val <= l2.val:
                prev.next = l1
                l1 = l1.next
            else:
                prev.next = l2
                l2 = l2.next
            prev = prev.next

        prev.next = l1 if l1 is not None else l2
        return prehead.next

    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        if len(lists) == 0: return None
        if len(lists) == 1: return lists[0]
        if len(lists) == 2: return self.mergeTwoLists(lists[0], lists[1])

        mid = len(lists) / 2
        lists1, lists2 = [], []
        for i in range(mid):
            lists1.append(lists[i])
        for j in range(mid, len(lists)):
            lists2.append(lists[j])
        l1 = self.mergeKLists(lists1)
        l2 = self.mergeKLists(lists2)
        return self.mergeTwoLists(l1, l2)