Merge k Sorted Lists

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

方法１．最直接的做法就是每次都遍历众多链表的头节点，找出其中最小的一个．假设所有链表的长度为ｎ，那么该算法的时间复杂度为Ｏ（ｎ＾２）．

方法２．用这些链表建立一个最小堆，根节点保存的是最小头节点元素的链表．每次取出根节点链表的第一个元素，放入新的链表中．如果取出后，根节点的链表为空，则将最后一个叶子节点的链表放入根节点．因为根节点的头元素值发生了改变，所以，我们需要从根节点向下调整堆．调整后，依然是最小堆．根据需要，我们只需实现建堆，和向下调整堆．每次调整堆，最多需要从根节点到叶子节点，复杂度为Ｏ（ｌｏｇn）．因此，该算法的时间复杂度为Ｏ（ｎｌｏｇｎ）．

class Solution {
public:
	vector<ListNode*> build(vector<ListNode*> &lists) {
		vector<ListNode*> v;
		for (int i = 0; i < lists.size(); i++) {
			if (lists[i]!=NULL) v.push_back(lists[i]);
		}
		for (int i = v.size()/2-1; i >= 0; i--) {
			shiftDown(v,i);
		}
		return v;
	}
	void swap(ListNode* & a,ListNode* & b) {
		ListNode* tem=a;
		a=b;
		b=tem;
	}
	void shiftDown(vector<ListNode*> &lists,int i) {
		int child = 2*i+1;
		while (child < lists.size()) {
			if (child+1 < lists.size() && lists[child+1]->val < lists[child]->val)
				child++;
			if (lists[child]->val > lists[i]->val)
				break;
			swap(lists[i],lists[child]);
			i=child;
			child=2*i+1;
		}
	}
    ListNode* mergeKLists(vector<ListNode*>& lists) {
		lists = build(lists);
		if (lists.size()==0) return NULL;
		ListNode* result=new ListNode(0);
		ListNode* l=result;
		while(lists[0]) {
			l->val=lists[0]->val;
			lists[0]=lists[0]->next;
			if (lists[0]==NULL) {
				lists[0]=lists[lists.size()-1];
				lists.pop_back();
			}
			if (lists[0]) {
				l->next=new ListNode(0);
				l=l->next;
			}
			shiftDown(lists,0);
		}   
		return result;
    }
};

方法３．使用ｓｔｌ库的堆－ｐｒｉｏｒｉｔｙ_queue

struct less_than {
	bool operator()(ListNode* a, ListNode* b) {
		return a->val > b->val;
	}
};
class Solution {
public:
	ListNode* mergeKLists(vector<ListNode*>& lists) {
		priority_queue<ListNode*,vector<ListNode*>,less_than> q;
		for (int i = 0; i < lists.size(); i++)
			if (lists[i]!=NULL) q.push(lists[i]);
		if (q.size()==0) return NULL;
		ListNode* result=new ListNode(0);
		ListNode* l=result;
		while (q.size()) {
			ListNode* top=q.top();
			q.pop();
			l->val=top->val;
			if (top->next)
				q.push(top->next);
			if (q.size()) {
				l->next=new ListNode(0);
				l=l->next;
			}
		}
		return result;
    }
};