经典算法——合并K个有序链表

原创 2016年06月01日 21:46:57

一、题目要求:

将K个有序链表合并为一个有序链表


二、实现方法:

方法一:利用最小堆方法
用一个大小为K的最小堆(用优先队列+自定义降序实现)(优先队列就是大顶堆,队头元素最大,自定义为降序后,就变成小顶堆,队头元素最小),先把K个链表的头结点放入堆中,每次取堆顶元素,然后将堆顶元素所在链表的下一个结点加入堆中。





整体测试代码:

#include <vector>
#include <iostream>
#include<queue>
#include<set>
#include <functional> // std::greater
using namespace std;

struct ListNode
{
	int val;
	ListNode* next;
};

struct cmp
{
	bool operator()(ListNode* a, ListNode* b)
	{
		return a->val > b->val;
	}
};
//方法一:利用最小堆方法
//用一个大小为K的最小堆(用优先队列+自定义降序实现)(优先队列就是大顶堆,队头元素最大,自定义为降序后,就变成小顶堆,队头元素最小),
//先把K个链表的头结点放入堆中,每次取堆顶元素,然后将堆顶元素所在链表的下一个结点加入堆中。
ListNode* mergeKLists2(vector<ListNode*> lists)
{
	if (lists.size() == 0) return NULL;
	priority_queue<int, vector<ListNode*>, cmp> heap;
	for (int i = 0; i < lists.size(); ++i)
	{
		heap.push(lists[i]);
	}

	ListNode* newHead=NULL;
	ListNode* p=NULL;
	ListNode* q=NULL;
	while (!heap.empty())
	{
		q = heap.top();
		heap.pop();
		if (q->next != NULL)    heap.push(q->next);
		if (newHead == NULL)
		{ 
			newHead = q;
			p = q;
		}
		else
		{
			p->next = q;
			p = p->next;
		}
	}
	return newHead;
}

ListNode* CreateListNode(int value)
{
	ListNode* pNode = new ListNode();
	pNode->val = value;
	pNode->next = NULL;

	return pNode;
}

void DestroyList(ListNode* pHead)
{
	ListNode* pNode = pHead;
	while (pNode != NULL)
	{
		pHead = pHead->next;
		delete pNode;
		pNode = pHead;
	}
}

void ConnectListNodes(ListNode* pCurrent, ListNode* pNext)
{
	if (pCurrent == NULL)
	{
		printf("Error to connect two nodes.\n");
		exit(1);
	}
	pCurrent->next = pNext;
}



int main()
{
	vector<ListNode*> lists;
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(2);
	ListNode* pNode3 = CreateListNode(3);
	ListNode* pNode4 = CreateListNode(4);

	ListNode* pNode5 = CreateListNode(2);
	ListNode* pNode6 = CreateListNode(3);
	ListNode* pNode7 = CreateListNode(4);
	ListNode* pNode8 = CreateListNode(5);

	ListNode* pNode9 = CreateListNode(6);
	ListNode* pNode10 = CreateListNode(7);
	ListNode* pNode11 = CreateListNode(8);
	ListNode* pNode12 = CreateListNode(9);

	ConnectListNodes(pNode1, pNode2);
	ConnectListNodes(pNode2, pNode3);
	ConnectListNodes(pNode3, pNode4);

	ConnectListNodes(pNode5, pNode6);
	ConnectListNodes(pNode6, pNode7);
	ConnectListNodes(pNode7, pNode8);

	ConnectListNodes(pNode9, pNode10);
	ConnectListNodes(pNode10, pNode11);
	ConnectListNodes(pNode11, pNode12);

	ListNode* L1 = pNode1;
	ListNode* L2 = pNode5;
	ListNode* L3 = pNode9;
	cout << "链表l1: ";
	while (L1)
	{
		cout << L1->val << " ";
		L1 = L1->next;
	}
	cout << endl;
	cout << "链表l2: ";
	while (L2)
	{
		cout << L2->val << " ";
		L2 = L2->next;
	}
	cout << endl;

	cout << "链表l3: ";
	while (L3)
	{
		cout << L3->val << " ";
		L3 = L3->next;
	}
	cout << endl;

	lists.push_back(pNode1);
	lists.push_back(pNode5);
	lists.push_back(pNode9);
	ListNode* res = mergeKLists2(lists);

	cout << "合并后链表: ";
	while (res)
	{
		cout << res->val << " ";
		res = res->next;
	}
	cout << endl;
	system("pause");
	DestroyList(res);
	return 0;
}



方法二:分治法

利用归并排序的思想,利用递归和分治法将链表数组划分成为越来越小的半链表数组,再对半链表数组排序,最后再用递归步骤将排好序的半链表数组合并成为越来越大的有序链表。





整体测试代码:


#include <iostream>
#include <vector>
using namespace std;

struct ListNode
{
	int val;
	ListNode* next;
};




//方法二:分治法
//利用归并排序的思想,利用递归和分治法将链表数组划分成为越来越小的半链表数组,
//再对半链表数组排序,最后再用递归步骤将排好序的半链表数组合并成为越来越大的有序链表
ListNode* mergeKLists(vector<ListNode*> lists, int K)
{
	return mergeLists(lists, 0, K);
}

ListNode* mergeLists(vector<ListNode*> listNodes, int low, int high)
{
	if (low == high) return NULL;
	if (high - low == 1) return listNodes[low];
	if (high - low == 2) return merge2(listNodes[low], listNodes[high - 1]);
	int mid = (high + low) / 2;
	ListNode* a = mergeLists(listNodes, low, mid);
	ListNode* b = mergeLists(listNodes, mid, high);
	return merge2(a, b);
}

ListNode* merge2(ListNode* L1, ListNode* L2)
{
	if (L1 == NULL && L2 == NULL) return NULL;
	else if (L1 == NULL) return L2;
	else if (L2 == NULL) return L1;
	ListNode*  newHead = NULL;
	ListNode* p = NULL;
	if (L1->val < L2->val){ newHead = L1; p = L1; L1 = L1->next; }
	else{ newHead = L2; p = L2; L2 = L2->next; }
	while (L1 != NULL && L2 != NULL)
	{
		if (L1->val < L2->val)
		{
			p->next = L1;
			L1 = L1->next;
		}
		else
		{
			p->next = L2;
			L2 = L2->next;
		}
		p = p->next;
	}
	p->next = L1 ? L1 : L2;

	return newHead;
}

ListNode* CreateListNode(int value)
{
	ListNode* pNode = new ListNode();
	pNode->val = value;
	pNode->next = NULL;

	return pNode;
}

void DestroyList(ListNode* pHead)
{
	ListNode* pNode = pHead;
	while (pNode != NULL)
	{
		pHead = pHead->next;
		delete pNode;
		pNode = pHead;
	}
}

void ConnectListNodes(ListNode* pCurrent, ListNode* pNext)
{
	if (pCurrent == NULL)
	{
		printf("Error to connect two nodes.\n");
		exit(1);
	}
	pCurrent->next = pNext;
}



int main()
{
	vector<ListNode*> lists;
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(2);
	ListNode* pNode3 = CreateListNode(3);
	ListNode* pNode4 = CreateListNode(4);

	ListNode* pNode5 = CreateListNode(2);
	ListNode* pNode6 = CreateListNode(3);
	ListNode* pNode7 = CreateListNode(4);
	ListNode* pNode8 = CreateListNode(5);

	ListNode* pNode9 = CreateListNode(6);
	ListNode* pNode10 = CreateListNode(7);
	ListNode* pNode11 = CreateListNode(8);
	ListNode* pNode12 = CreateListNode(9);

	ConnectListNodes(pNode1, pNode2);
	ConnectListNodes(pNode2, pNode3);
	ConnectListNodes(pNode3, pNode4);

	ConnectListNodes(pNode5, pNode6);
	ConnectListNodes(pNode6, pNode7);
	ConnectListNodes(pNode7, pNode8);

	ConnectListNodes(pNode9, pNode10);
	ConnectListNodes(pNode10, pNode11);
	ConnectListNodes(pNode11, pNode12);

	ListNode* L1 = pNode1;
	ListNode* L2 = pNode5;
	ListNode* L3 = pNode9;
	cout << "链表l1: ";
	while (L1)
	{
		cout << L1->val << " ";
		L1 = L1->next;
	}
	cout << endl;
	cout << "链表l2: ";
	while (L2)
	{
		cout << L2->val << " ";
		L2 = L2->next;
	}
	cout << endl;

	cout << "链表l3: ";
	while (L3)
	{
		cout << L3->val << " ";
		L3 = L3->next;
	}
	cout << endl;

	lists.push_back(pNode1);
	lists.push_back(pNode5);
	lists.push_back(pNode9);
	ListNode* res = mergeKLists(lists, 3);

	cout << "合并后链表: ";
	while (res)
	{
		cout << res->val << " ";
		res = res->next;
	}
	cout << endl;
	system("pause");
	DestroyList(res);
	return 0;
}


版权声明:本文为博主原创文章,未经博主允许不得转载。

合并k个有序链表

leetcode题目: 23. Merge k Sorted Lists    Merge k sorted linked lists and return it as one sorte...

堆排序之“用最小堆将k个已排序链表合并为一个排序链表”

问题:请给出一个时间为O(nlgk),用来将k个已排序链表合并为一个排序链表的算法。此处的n为所有输入链表中元素的总数。(提示:用一个最小堆来做k路合并) 编程思路: 假设k个链表都是非降...

合并k个有序数组

题目: 合并k个有序数组。 分析: 利用一个大小为k的小根堆(代码里用multiset表示),每次取堆顶的数字,直到大根堆为空。 struct node { vector>* ptr; int...

合并k个排序链表

题目合并k个排序链表,并且返回合并后的排序链表。尝试分析和描述其复杂度。 样例 给出3个排序链表[2->4->null,null,-1->null],返回 -1->2->4->null解题两两合并...

Leetcode #23 Merge k Sorted Lists 合并K个有序列表 解题报告

1 解题报告嗯,这道题又是一系列的题了。。再看这个之前请先看下K=2的情况时,应该怎么做 Leetcode #21 Merge Two Sorted Lists 合并有序链表 解题报告嗯,我好想就...
  • MebiuW
  • MebiuW
  • 2016年03月25日 23:28
  • 671

O(N lgK) 时间内合并K个有序链表

问题: 在O(N lgK) 时间内合并K个有序链表, 这里N指的是K个链表中所有的元素个数。 分析: 这是一道非常经典的面试题,在很多大公司的面试题中,此题频繁出现。这题也是算法导论的作业题。 ...

合并k个有序链表

23. Merge k Sorted Listsstruct ListNode* mergeTwoLists(struct ListNode *l1,struct ListNode *l2) { ...

用最小堆将k个已排序链表合并为一个排序链表

问题:请给出一个时间为O(nlgk),用来将k个已排序链表合并为一个排序链表的算法。此处的n为所有输入链表中元素的总数。 编程思路: 假设k个链表都是非降序排列的。 (1)取k个元素建立最小堆,...

合并K个有序数组

堆排序

数据结构之有序链表的归并

涉及到链表的建立、删除、输入、输出 链表的归并 #include using namespace std; #define ERROR 0 #define OK 1 typedef int Ele...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:经典算法——合并K个有序链表
举报原因:
原因补充:

(最多只允许输入30个字)