LeetCode 23. Merge k Sorted Lists

题目

思路，维护一个最小堆。

一开始把二维数组里的每一维的第一个元素都放到堆里。也就是第一列的元素都放到堆里。

此后，出堆。再进堆，没次出堆，都把 出堆的元素 在数组里的下一个元素 入堆。循环这种操作。

每次出堆的元素都是最小的。

这样的效率就是O(n*log(n))

one pass && faster than 94.84% of C++

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

struct Node
{
    int val;
    int index;
} a[10005];

int pos=0;
void up()
{
    int j=pos;
    while(j>1)
    {
        if(a[j].val<a[j/2].val)
        {
            swap(a[j],a[j/2]);
            j=j/2;
        }
        else
        {
            break;
        }
    }
}

void down()
{
    int j=1;
    int i=j*2;
    while(i<=pos)
    {
        if(i<pos&&a[i].val>a[i+1].val)
        {
            i++;
        }
        if(a[j].val>a[i].val)
        {
            swap(a[j],a[i]);
            j=i;
            i=j*2;
        }
        else
        {
            break;
        }
    }
}

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        
       
       for(int i=0;i<lists.size();i++)
       {
           if(lists[i]!=NULL)
           {
              a[++pos].val=lists[i]->val; 
              a[pos].index=i;
                
              up();
              lists[i]=lists[i]->next;
            }
        }
        ListNode* ans = new ListNode(0);
        ListNode* res = ans;
        int id=0;
        while(pos>=1)
        {
            res->next =  new ListNode(a[1].val);
            res=res->next;
            id = a[1].index;
            
            a[1]=a[pos];
            pos--;
            down();
            
            if(lists[id]!=NULL){
                a[++pos].val=lists[id]->val;
                a[pos].index=id;
                up();
                
                lists[id] = lists[id]->next;
            }
        }
        
        return ans->next;
        
    }
};