LeetCode 之 Merge Two / k Sorted Lists — C/C++ 实现

Merge Two Sorted Lists

 

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

将两个有序链表合并并返回新的链表。新链表是由原链表的节点链接组成。

分析：

维护一个新的头指针，分别从 L1 和 L2 的头结点开始向后比较，将值小的节点加入新链表，然后指针后移，另一个不变，重复此过程直到两个链表合并完。

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode *head = NULL, *pre = NULL;
    
    if(!l2) //l2为空指针,直接返回l1
    {
        return l1;
    }
    if(!l1)//l2不为空，l1为空
    {
        l1 = l2;
        return l1;
    }

    while(l1 || l2)
    {
        if(!l1) /* l1合并完成，l2没完成 */
        {
            pre->next = l2;
            pre = pre->next;
            l2 = l2->next;
            continue;
        }
        if(!l2)/* l2合并完成，l1没有完成 */
        {
            pre->next = l1;
            pre = pre->next;
            l1 = l1->next;
            continue;
        }
        
        /* l1 l2 都没合并完*/
        if(NULL == head)/*第一个节点*/
        {
            if(l1->val <= l2->val) /*l1小，加入新链表*/
            {
                head = pre = l1;
                l1 = l1->next;
                if(pre->val == l2->val)/*l1 l2 相等，都加入新链表*/
                {
                    pre->next = l2;
                    pre = pre->next;
                    l2 = l2->next;
                }
            }
            else/*l2 小，加入新链表*/
            {
                head = pre = l2;
                l2 = l2->next;
            }
        }
        else
        {
            if(l1->val <= l2->val) /*l1小，加入新链表*/
            {
                pre->next = l1;
                l1 = l1->next;
                pre = pre->next;
                if(pre->val == l2->val)/*l1 l2 相等，都加入新链表*/
                {
                    pre->next = l2;
                    pre = pre->next;
                    l2 = l2->next;
                }
            }
            else/*l2 小，加入新链表*/
            {
                pre->next = l2;
                pre = pre->next;
                l2 = l2->next;
            }
        }
    }
    
    return head;
}

Merge k Sorted Lists

 

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

将 k 个有序链表合并成一个新链表并返回，分析和描述复杂度。

分析：

归并排序。对每个有序链表看成一个整体，然后和其他的链表进行归并排序。时间复杂度为 O(nlogn).

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.empty()) //空
        {
            return NULL;
        }
        if(lists.size() == 1)
        {
            return lists[0];
        }
        
        //归并排序
        return mergeList(lists);
    }
    
    //划分   
    ListNode* mergeList(vector<ListNode*>& lists){
        int listsSize = lists.size();
        
        if(1 == listsSize)
        {
            return lists[0];
        }
        
        vector<ListNode*> vleft(lists.begin(), (lists.begin() + (listsSize-1)/2 + 1));
        vector<ListNode*> vright((lists.begin() + (listsSize-1)/2 + 1), lists.end());
        ListNode *left = mergeList(vleft);//左半部分归并排序
        ListNode *right = mergeList(vright);//右半部分归并排序
        return merge2Lists(left, right);
    }
    
    //合并
    ListNode* merge2Lists(ListNode* left, ListNode* right){
        if(!left && !right)
        {
            return NULL;
        }
        
        ListNode *tempHead = new ListNode(0), *pre = tempHead; //新建头结点
        ListNode *head = left;
        ListNode *plist = right;

        while(head || plist)
        {
            if(!head) //head合并完，lists[i]没有完成
            {
                pre->next = plist;
                pre = pre->next;
                plist = plist->next;
                
                continue;
            }
            if(!plist)//lists[i]合并完，head没有完成
            {
                pre->next = head;
                pre = pre->next;
                head = head->next;
                
                continue;
            }
            
            if(head->val <= plist->val)//head <= lists[i]
            {
                pre->next = head;
                pre = pre->next;
                head = head->next;
                
                if(pre->val == plist->val)//注意：此处是 pre->val, head已经指向下个节点
                {
                    pre->next = plist;
                    pre = pre->next;
                    plist = plist->next;
                }
            }
            else //head > lists[i]
            {
                pre->next = plist;
                pre = pre->next;
                plist = plist->next;
            }
        }
        
        head = tempHead->next;
        delete tempHead;
        
        return head; 
    }
};