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

一、题目要求：

将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;
}

时间： 2024-10-08 01:44:58

经典算法——合并K个有序链表的相关文章

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

题目描述 Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists. 完整测试程序: #include <iostream> using namespace std; struct ListNode { int val; ListNode* next; }; ListNod

[LeetCode] 23. Merge k Sorted Lists 合并k个有序链表

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 与21. Merge Two Sorted Lists的拓展,这道题要合并k个有序链表,还是可以两两合并. 类似题目: [LeetCode] 21. Merge Two Sorted Lists 合并有序链表原文地址:https://www.cnblogs.com/lightwindy/p/8512

合并k个有序链表

题目: 合并k个有序链表,并将结果用一个有序链表输出例如:输入: [ 1->4->5, 1->3->4, 2->6 ] 输出: 1->1->2->3->4->4->5->6 思路: 假设k个链表的总元素数目为n.首先想到两两合并列表,在序列1和2合并,3和4合并,依次类推.直到合并的只剩一个链表.这种操作的时间复杂度为O(nlog(k)),空间复杂度为O(1).python代码如下: class Solution(obj

leetcode python 012 hard 合并k个有序链表

#[LeetCode] Merge k Sorted Lists 合并k个有序链表(升序) import numpy as npimport time class Node(object): def __init__(self,n,next_node=None): self.data=n self.next=next_node class linklist(object): def __init__(self): self.head=N

23. Merge k Sorted Lists 合并K个有序链表

这道题是21题合并2个有序链表的升级版本,看了许多解题思路: A:直接暴力解锁,全部放进一个堆,然后依次吐出来: B:利用21题的算法,循环一次做两两合并,这样就得到结果:但是时间复杂度有点差: C:利用归并排序思想,进行分治:其实就是利用递归,牺牲空间,提升时间效率: 存在的问题是:看过了许多解答后发现,大家基于的给定数据类型是 List<ListNode>/ArrayList<ListNode>,然后,现在系统更新了,给的数据类型是 ListNode[] lists,所以,我现

leetcode 23 合并 k 个有序链表

问题描述 * leetcode 23, Merge k Sorted Lists 解题思路合并2个有序链表的进阶版,很容易想到,利用分治进行处理. 把个数大于2的集合两两划分处理,最后再做最后一步的处理. 1 public class Solution { 2 public ListNode mergeKLists(ListNode[] lists) { 3 if (lists.length==0 || lists==null) { return null; } 4 return merg

p122 合并 K 个有序链表(leetcode 23)

一:解题思路方法一:之前做过一道合并2个链表的题目,那么第一种方法就是将数组中的链表两两合并,得到最后的结果.Time:O(k*n),Space:O(1) 方法二:采用分治法,两两合拼.不断递归,最后只剩下一个链表.Time:O(n*log(k)),Space:O(log(k)) 二:完整代码示例 (C++版和Java版) 方法一C++: class Solution { private: ListNode* mergeTwoSortedLists(ListNode* l1, ListNode

每天一个小算法（2）----合并两个有序链表

每天一个小算法还是有点没时间,尽量抽出时间写一写. 今天是合并有序的链表,对单链表有点忘了,尤其是指针指来指去的,有点晕,幸好基础还算好,想了想还是能想回来. 代码使用随机数函数生成一个链表,然后对链表排序,最后合并链表并打印,删除链表的函数于算法无关紧要,所以未实现^_^. 在Linux/g++下编译运行成功. 合并思路:和合并数组有些类同,比较两个节点的元素大小然后将小的摘下来尾插到链表bList中,然后指针指向下一个节点,最后直接把非空的链表合并到bList的末尾. 1 #include

23. 合并K个排序链表

知乎ID: 码蹄疾码蹄疾,毕业于哈尔滨工业大学. 小米广告第三代广告引擎的设计者.开发者: 负责小米应用商店.日历.开屏广告业务线研发:主导小米广告引擎多个模块重构: 关注推荐.搜索.广告领域相关知识; 题目合并 k 个排序链表,返回合并后的排序链表.请分析和描述算法的复杂度.示例:输入:[ 1->4->5, 1->3->4, 2->6]输出: 1->1->2->3->4->4->5->6 分析前面已经做过两个有序链表的合并,只