[leetcode]23. Merge k Sorted Lists

23. Merge k Sorted Lists

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

Example:

Input:
[
  1->4->5,
  1->3->4,
  2->6
]
Output: 1->1->2->3->4->4->5->6

我比较蠢，第一反应就是暴力。。。于是就暴力去过了。。

思路就是把所有链表元素都放进数组，然后使用快速排序，最后重新建立链表返回头指针就OK了。。。

emm由于C++<algorithm>头文件里面有sort函数，这用的是快速排序，直接用就行了，时间复杂度也比较小。

提交的时候错了好几次。。由于忘了处理空列表，以及列表里面有空链表的情况。。

后面用一个flag处理成功了。。。

具体代码如下：

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.empty())
            return NULL;
		vector<int>list_to_array;
        
        bool flag = false;
		for (int i = 0; i < lists.size(); i++) {
            if(lists[i] == NULL)
                continue;
            else
                flag = true;
			ListNode *temp = lists[i];
			while (temp != NULL) {
				list_to_array.push_back(temp->val);
				temp = temp->next;
			}
		}
        
        if(flag == false)
            return NULL;
        
		int *answer_array = new int[list_to_array.size()];
        for(int i = 0;i < list_to_array.size();i++){
            answer_array[i] = list_to_array[i];
        }
        
		sort(answer_array, answer_array + list_to_array.size());

		ListNode* move;
		ListNode *head;
		ListNode *temp = new ListNode(0);
		move = temp;
		head = temp;
		move->val = answer_array[0];
		for (int i = 1; i < list_to_array.size();i++) {
			ListNode *temp1 = new ListNode(0);
			move->next = temp1;
			move->next->val = answer_array[i];
			move = move->next;
		}

		return head;
	}
};

后面看了看Leetcode solution里面看看有没有其他解法。。毕竟暴力嘛。。。emmm

看到了一种算法就是逐个比较，由于这些链表是实现排好序的，可以从每一个链表的第一个元素开始比，然后把最小的放进新链表，然后该链表就向后推移，这样也是一个很好的思路。还有一种思路好像是用的优先队列，我认为也是不错的思路。。不过还没认真看。。

结果发现我这暴力解法实在是有点低级2333。。不过好歹是过了就行了