Leet Code OJ 23合并K个排序链表

最新推荐文章于 2021-12-31 20:40:56 发布

循环是人递归是神

最新推荐文章于 2021-12-31 20:40:56 发布

阅读量108

点赞数

分类专栏： Leetcode

本文链接：https://blog.csdn.net/qq_35752161/article/details/103056969

版权

Leetcode 专栏收录该内容

67 篇文章 0 订阅

订阅专栏

两种方法：

1.归并排序。

2.将链表元素全部放入数组进行快速排序，然后放回去。

方法1复杂度：假设有k个链表，共有N个元素。归并次数为logK，每次合并的复杂度为N。总的复杂度为NlogK

方法2复杂度：快速排序复杂度为NlogN

理论上，法1的复杂度更低

但是实际运行结果，法2更快。。。

    ListNode* merge2lists(ListNode* l1, ListNode* l2)
    {
        if(l1 == NULL)
            return l2;
        if(l2 == NULL)
            return l1;
        if(l1->val>l2->val)
        {
            l2->next = merge2lists(l1,l2->next);
            return l2;
        }
        else
        {
            l1->next = merge2lists(l1->next,l2);
            return l1;
        }
    }
    ListNode* merge(int l, int r, vector<ListNode*> & lists)
    {
        if(l<r)
        {
            int mid = (l + r)/2;
            ListNode* l1 = merge(l,mid,lists);
            ListNode* l2 = merge(mid + 1, r,lists);
            return merge2lists(l1,l2);
        }
        return lists[l];
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) 
    {
        if(lists.size() == 0)
            return NULL;
        return merge(0, lists.size() - 1, lists);
    }

ListNode* mergeKLists(vector<ListNode*>& lists)
{
	vector<int> a;
	for (int i = 0; i < lists.size(); i++)
	{

		while (lists[i] != NULL)
		{
			a.push_back(lists[i]->val);
			lists[i] = lists[i]->next;
		}
	}
	sort(a.begin(), a.end());
	ListNode* head = new ListNode(0);
	ListNode* phead = head;
	for (int i = 0; i < a.size(); i++)
	{

		ListNode* head1 = new ListNode(NULL);
		head1->val = a[i];
		phead->next = head1;
		phead = phead->next;
	}
	return head->next;
}