Leetcode--Merge k Sorted Lists

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

Hide Tags

  Divide and Conquer Linked List Heap

Have you met this question in a real interview?

Solution 1:

1)遍历所有list，将其值放入vector中  2)将vector中的元素排序  3）将排序后的元素重新组装成链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> v;
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        for( int i=0;i<lists.size();i++)
        {
            ListNode * cur=lists[i];
            while(cur!=NULL)
            {
                v.push_back(cur->val);
                cur=cur->next;
            }
        }
        
        if(v.size()<1)
            return NULL;
        
        
        ListNode * result = NULL;
        sort(v.begin(),v.end());
        
        
        for(int i=v.size()-1; i>=0;i--)
        {
            if(i==v.size()-1)
            {
                result=(ListNode*)malloc(sizeof(ListNode));
                result->next = NULL;
                result->val = v[i];
            }
            else{
                ListNode *tmp=(ListNode*)malloc(sizeof(ListNode));
                tmp->next = result;
                tmp->val = v[i];
                
                result=tmp;
            }
        }
        
        return result;
    }
};

Solution 2:

假设 lists中有3个链表分别是是 lists[0]、lists[1]、lists[2], 考虑到这三个链表都是有序的，所以只需要比较三个链表中的第一个元素，找寻出最小的val，并将该链表的当前指针后移一位，重复进行，知道容器中只剩一个非空链表。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        /*int num = 0;
        for(int i=0;i<lists.size();i++)
        {
            ListNode *  tmp=lists[i];
            while(tmp!=NULL)
            {
                num++;
                tmp=tmp->next;
            }
        }*/
        int len = lists.size();
        if(len<1)
            return NULL;
        else if(len==1)
            return lists[0];
            

        ListNode * result=NULL;
        ListNode * cur =  result;
        while((len=lists.size())>1)
        {
            map<int,int> m;
            int min=0x3f3f3f3f;
            for(int i=0;i<len;i++)
            {
                if(lists[i]==NULL)
                {
                    lists.erase(lists.begin()+i);
                    break;
                }
                else
                {    
                    m.insert(make_pair(lists[i]->val,i));
                    if(lists[i]->val<min)
                        min=lists[i]->val;
                    
                    
                }
                    
            }
            if(result==NULL&&min<0x3f3f3f3f)
            {
                result=(ListNode*)malloc(sizeof(ListNode));
                result->val=min;
                result->next=NULL;
                cur = result;
                
                //m[min]=m[min]->next;
                lists[m[min]]=lists[m[min]]->next;
                
            }
            else if(min<0x3f3f3f3f){
                ListNode *tmp = (ListNode*)malloc(sizeof(ListNode));
                tmp->val = min;
                tmp->next = NULL;
                cur->next = tmp;
                cur = tmp;
                
                //m[min]=m[min]->next;
                lists[m[min]] = lists[m[min]]->next;
            }
            
        }
        
        if(lists[0]!=NULL)
        {
            if(result==NULL)
            {
                result = lists[0];
            }
            else
                cur->next = lists[0];
        }
            
        return result;
    }
};

Status: 

Time Limit Exceeded