Leetcode-Merge k Sorted Lists

最新推荐文章于 2019-02-25 10:47:54 发布
最新推荐文章于 2019-02-25 10:47:54 发布
阅读量284 收藏
点赞数
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/starstar1992/article/details/53958415
版权

题目：
https://leetcode.com/problems/merge-k-sorted-lists/

五种方法

  1. 蛮力算法，两个合并，得到的结果再和另外一个合并，直到最后。
    复杂度为O(N*K^2)
/*------------------------------------------------------------------*/
class Solution1 {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {//两个两个比较，直到最后合成一个(这个方法超时，AC不了)复杂度O(N*K^2)
        ListNode* result=NULL;

        if(lists.size()==0) return result;
        else if(lists.size()==1) return lists[0];
        else
        {
            for(int i=0;i<lists.size();i++)
            {
                if(i==0)
                {
                   result=merge2Lists(lists[0],lists[1]);
                }
                else if(i>=2)
                {
                   result=merge2Lists(lists[i],result);
                }
            }
            return result;
        }



    }

private:
    ListNode *merge2Lists(ListNode*l1,ListNode*l2 )
    {

        if(l1==NULL) return l2;
        else if(l2==NULL) return l1;
        else
        {
            ListNode *res=NULL;
            if(l1->val<l2->val)
            {
                res=l1;
                res->next=merge2Lists(l1->next,l2);
            }
            else
            {
                res=l2;
                res->next=merge2Lists(l1,l2->next);
            }
            return res;
        }
    }

};

2.

分治法（两个两个合并，第一次合并结束，是k/2个序列，再两个两个合并，第二次合并结束是 k/4，最后的复杂度是O(N*log(K))）

/*------------------------------------------------------------------*/

class Solution2 {//复杂度：O(N*log(K))  空间复杂度大
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {//分治法，一半一半比较，直到最后合成一个(这个方法AC了，不会存在空间超出限制,70%排名)
        ListNode* result=NULL;

        if(lists.size()==0) return result;
        else if(lists.size()==1) return lists[0];
        return merg(lists,0,lists.size()-1);
    }
private:
    ListNode *merg(vector<ListNode*>& lists,int left,int right)
    {
     if(left<right)
     {
         int mid=(right+left)/2;
         return merge2Lists(merg(lists,left,mid),merg(lists,mid+1,right));
     }
        return lists[left];//返回左边那个，其实这时左边等于右边。return[right]效果一样
    }
  ListNode *merge2Lists(ListNode*l1,ListNode*l2 )
    {

        if(l1==NULL) return l2;
        else if(l2==NULL) return l1;
        else
        {
            ListNode *res=NULL;
            if(l1->val<l2->val)
            {
                res=l1;
                res->next=merge2Lists(l1->next,l2);
            }
            else
            {
                res=l2;
                res->next=merge2Lists(l1,l2->next);
            }
            return res;
        }
    }


};

3
分治法，不采用递归，复杂度同2，但空间复杂度降低了为O(1)

/*------------------------------------------------------------------*/
 //分治法，不采用递归，把第二种递归方法转化为非递归方法

class Solution3 {//复杂度：O(N*log(K))  空间复杂度小
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {//分治法，AC，89%)
        ListNode* result=NULL;
        if(lists.size()==0) return result;
        else if(lists.size()==1) return lists[0];
        else
        {
            int len=lists.size();
            while(true)
            {
               for(int i=0;i<=len/2;i++)
                {
                    if(len%2==0&&i<len/2)
                    {
                        lists[i]=merge2Lists(lists[i],lists[len-i-1]);
                    }
                    else if(len%2==1)
                    {
                        if(i<len/2) lists[i]=merge2Lists(lists[i],lists[len-i-1]);
                        else lists[i]=lists[i];
                    }
                }
                if(len%2==0) len=len/2;
                else len=len/2+1;
                if(len==1)
                    break;
            }
         return lists[0];
        }
    }

ListNode *merge2Lists(ListNode*l1,ListNode*l2 )
    {

        if(l1==NULL) return l2;
        else if(l2==NULL) return l1;
        else
        {
            ListNode *res=NULL;
            if(l1->val<l2->val)
            {
                res=l1;
                res->next=merge2Lists(l1->next,l2);
            }
            else
            {
                res=l2;
                res->next=merge2Lists(l1,l2->next);
            }
            return res;
        }
    }
};

4
使用STL的优先队列，即小顶堆的性质。复杂度：O(NK*log(K)) 堆排序

/*------------------------------------------------------------------*/
//优先队列（其实就是大顶堆排序），使用STL的自动建堆

class Solution4 {//复杂度：O(NK*log(K))  堆排序
public:
    struct cmp{
            bool operator()(ListNode *a,ListNode *b){//大的在下，小的在上
                return a->val>b->val;
            }
        };
    ListNode* mergeKLists(vector<ListNode*>& lists) { 

        ListNode* result=NULL;
        if(lists.size()==0) return result;
        else if(lists.size()==1) return lists[0];

        priority_queue<ListNode *,vector<ListNode*>,cmp> queue;
        for(int i=0;i<lists.size();i++)
        {
            if(lists[i]!=NULL)//对于非空的，加入堆中
                queue.push(lists[i]);//建立堆
        }

        ListNode *head=NULL,*prev=NULL,*temp;

        while(!queue.empty()){
            temp=queue.top();//获取堆顶元素，也就是等效于获取当前所有链表中最小的那个元素
            queue.pop();//弹出顶部元素

            if(prev==NULL)
            {
                prev=temp;
                head=prev;//第一个元素给head，即用head指向第一个元素
            }
            else
            {
                prev->next=temp;//以后的元素都赋给prev->next
                prev=prev->next;//prev指向它的下一个元素
            }

            if(temp->next!=NULL)//也就是说temp所在的链表还有元素（temp后面的），就把temp后面的元素加入堆中
            {
                queue.push(temp->next);
            }
        }
    return head;//返回指向第一个元素的指针，也就是返回已经排好序的一大串
    }
};

5
自己写的小顶堆，不适用STL的。复杂度同4.

/*------------------------------------------------------------------*/
//自己建立堆

class Solution { 
public:
    ListNode* mergeKLists(vector<ListNode*>& lists){
        ListNode* result=NULL;
        if(lists.size()==0) return result;
        else if(lists.size()==1) return lists[0];

        vector<ListNode *>heap;
        for(int i=0;i<lists.size();i++)
            if(lists[i]) heap.push_back(lists[i]);

        makeheap(heap);//建堆函数，自己写

        ListNode *head=NULL,*prev=NULL,*temp;
        while(!heap.empty())
        {
            temp=heap_pop(heap);//弹出堆顶元素，并返回，自己写这个函数
            if(prev==NULL)
            {
                prev=temp;
                head=prev;
            }
            else
            {
                prev->next=temp;
                prev=prev->next;
            }

            if(temp->next!=NULL)
            {
                heap_push(heap,temp->next);//加入新元素，自己写这个函数
            }

        }

        return head;
    }


private:

 void makeheap(vector<ListNode *> &heap)
 {
     for(int i=heap.size()/2;i>0;i--)//堆的序号是从1到heap.size()/2
        minHeap(heap,i);
 }


void minHeap(vector<ListNode *> &heap,int i)//以i为父节点的子树,建立堆
{
    int lchild=2*i;//i的左孩子节点序号(序号是从1开始)
    int rchild=2*i+1;//i的右孩子节点序号
    int least=i;//临时变量
    if(lchild<=heap.size()&&heap[lchild-1]->val<heap[least-1]->val)
    {
        least=lchild;
    }

    if(rchild<=heap.size()&&heap[rchild-1]->val<heap[least-1]->val)
    {
        least=rchild;
    }
    //上述两个if是为了获取i节点，i节点的左右孩子三个中最小的那个，下标存到least
    if(least!=i)//不是父节点i
    {
        swap(heap[i-1],heap[least-1]);
        minHeap(heap,least);//避免调整之后以least为父节点的子树不是堆（因为此时左右子树的一个和父节点换了，那么换后的左右子树那个还要继续调整）
    }
}
void swap(ListNode *&a,ListNode *&b)//指针作为形参传递，加引用才能在调用时更改其值！（这儿困惑了好久，一直不明白）
{
    ListNode * c;
    c=a;
    a=b;
    b=c;
}

void heap_push(vector<ListNode*> &heap,ListNode * p)
{
    heap.push_back(p);//把该链表加入heap中
    //minHeap(heap, 1);
    for(int child=heap.size(),parent=child/2;parent>0;child=child/2,parent=child/2) //因为添加的元素是最后一个，所以只需从底部向上进行判断
    {
        if(heap[child-1]->val<heap[parent-1]->val)
            swap(heap[child-1],heap[parent-1]);
    }
}


ListNode*heap_pop(vector<ListNode *>&heap)//删除堆顶的元素，并返回
{
    swap(heap[0],heap[heap.size()-1]);//把最后一个和第一个交换，是为了方便删除第一个
    ListNode* p=heap[heap.size()-1];//获取最后一个
    heap.pop_back();
    minHeap(heap,1);//重新建立堆（第一步交换后，要重新调整顺序），因为现在的第一个是原来的最后一个，所以要从头到尾堆排序一下
    return p;
}
};

总结：2，3，4，5都AC了，1 TLE。另外自己写小顶堆，错误很多，好多没考虑清楚的，调试了好久，不过写一次确实能锻炼能力。

路漫远吾求索
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode——Merge k Sorted Lists(23)
Pokemon_Master的博客
09-26 160
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. Example: Input: [   1-&gt;4-&gt;5,   1-&gt;3-&gt;4,   2-&gt;6 ] Output: 1-&gt;1-&gt;2-&gt;3-&gt;4-...
LeetCode:23 Merge k Sorted Lists
erzhushashade的博客
07-05 160
problem LeetCode 23. Merge k Sorted Lists Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. solution 方法一 思路过程 代码 python 在这里插入代码片 Java 在这里插入代码片
算法:Merge k Sorted Lists(合并 k 个排序链表)
AI架构师易筋
02-25 701
说明 算法：Merge k Sorted Lists LeetCode地址：https://leetcode.com/problems/merge-k-sorted-lists/ 题目： Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. Example...
LeetCode-Merge k Sorted Lists
坟头草一米七五
07-13 209
LeetCode Java Merge k Sorted Lists
leetCode-Merge k Sorted Lists-javascript实现
我也想变成大牛
12-24 176
题目链接：题目链接 题目大意描述：给定k个有序链表，合成一个有序链表 题目思路：维护两个数组一个存整数一个存负数，统计所有链表中的数字；再遍历数组，新建count[i]个节点并接在链表后面。 /** * Definition for singly-linked list. * function ListNode(val) { * this.val = val; * this...
c语言-leetcode 0023-merge-k-sorted-lists.zip
最新发布
08-23
c c语言_leetcode 0023_merge_k_sorted_lists.zip
c语言-leetcode 0021-merge-two-sorted-lists.zip
08-23
c c语言_leetcode 0021_merge_two_sorted_lists.zip
LeetCode Merge 2 Sorted Lists解决方案
01-23
LeetCode Merge 2 Sorted Lists解决方案详解 Merge 2 Sorted Lists是LeetCode上的一个经典算法题目，旨在考察程序员对链表的操作和排序算法的掌握程度。下面对该题目的解决方案进行详细的分析和解释。 问题描述 ...
day7-1110-leetcode之排序2-Merge Two Sorted Lists
qq_26549461的博客
11-27 230
LeetCode-Merge Two Sorted Lists 题目等级分析C++实现结果 题目 Merge two sorted linked lists and return it as a new list. e new list should be made by splicing together the nodes of the first two lists. 等级 easy 分析...
KMP算法最浅显理解——一看就明白
热门推荐
好记性不如烂笔头的专栏
02-07 32万+
说明 KMP算法看懂了觉得特别简单，思路很简单，看不懂之前，查各种资料，看的稀里糊涂，即使网上最简单的解释，依然看的稀里糊涂。 我花了半天时间，争取用最短的篇幅大致搞明白这玩意到底是啥。 这里不扯概念，只讲算法过程和代码理解： KMP算法求解什么类型问题 字符串匹配。给你两个字符串，寻找其中一个字符串是否包含另一个字符串，如果包含，返回包含的起始位置。 如下面两个字符串： c...
图的BFS和DFS之C++实现
好记性不如烂笔头的专栏
04-01 1万+
图的创建 手动输入，并以节点数作为输入结束标志 从文件读取，文件的从第二行开始，每一行结束都要有节点数作为结束 图的存储： vector< list<int> > graph;图的BFS非递归实现，借助队列void bfs(int v)//以v开始做广度优先搜索（非递归实现，借助队列） { list<int>::iterator it; visited[v] = true;
求最长连续线段长
好记性不如烂笔头的专栏
03-25 2457
循环int BinSearch(int a[], int n, int key) { int low = 0, high = n - 1, mid; while (low <= high) { if (a[low] == key) return low; if (a[high] == key) r
Leetcode——468. Validate IP Address
好记性不如烂笔头的专栏
02-08 1089
题目Write a function to check whether an input string is a valid IPv4 address or IPv6 address or neither.IPv4 addresses are canonically represented in dot-decimal notation, which consists of four decimal
Leetcode——276.Paint Fence
好记性不如烂笔头的专栏
02-21 1039
DescriptionThere is a fence with n posts, each post can be painted with one of the k colors.You have to paint all the posts such that no more than two adjacent fence posts have the same color.Return th
已知中序遍历和前序遍历，求后序遍历
好记性不如烂笔头的专栏
04-20 871
已知中序遍历和前序遍历，求后序遍历思路前序遍历：根 左 右 中序遍历：左 根 右 寻找根，然后对于中序遍历，根的左半部分和前序遍历的根后面的左那部分 又重新构成一个相同的子问题，递归求解即可。Code#pragma once #include<iostream> #include<stack> #include<queue> using namespace std; typedef struct
快排－单链表实现
好记性不如烂笔头的专栏
07-26 705
/************************************************************************* > File Name: main.cpp > Author: > Mail: > Created Time: 三 7/26 18:43:04 2017 *****************************
单源最短路径——Dijkstra算法
好记性不如烂笔头的专栏
04-01 700
原理解析http://blog.csdn.net/wizard_wsq/article/details/51095853小技巧总结图用邻接矩阵表示 Distance[i]表示v0到顶点i的距离 int prev[i]表示节点v0到节点i存在最短路径时，其前一个节点。Dijkstra代码//Dijkstra算法函数，求给定顶点到其余各点的最短路径 //参数：邻接矩阵、出发点的下标、结果数组、路径前
Leetcode-第十一题Container With Most Water
好记性不如烂笔头的专栏
12-27 682
题目链接https://leetcode.com/problems/container-with-most-water/题目Given n non-negative integers a1, a2, …, an, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the
Leetcode——93. Restore IP Addresses
好记性不如烂笔头的专栏
02-08 637
题目Given a string containing only digits, restore it by returning all possible valid IP address combinations.For example: Given “25525511135”,return [“255.255.11.135”, “255.255.111.35”]. (Order does no
LeetCode面试宝典：50经典问题详解与数据结构设计
- Merge K Sorted Linked Lists: 同时合并多个已排序链表，提升效率的方法。 - Copy List with Random Pointer: 复制链表的同时保留每个节点的随机指针指向关系。 章节4：二叉树（Binary Trees） - Validate Binary...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值