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

#[LeetCode] Merge k Sorted Lists 合并k个有序链表(升序)

import numpy as np
import 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=None

def init(self,data):
        assert type(data)==list,type(data)
        self.head=Node(data[0],None)
        p=self.head
        for i in data[1:]:
            node=Node(i)
            p.next=node
            p=p.next

def show(self):
        l=[]
        p=self.head
        while p:
            l.append(str(p.data))
            p=p.next
        print(‘->‘.join(l))
    
def hebing(link1,link2):
    p1,p2=link1.head,link2.head
    if p1.data>p2.data:
        return hebing(link2,link1)
    while p2:
        if not p1.next and p2.next:
            p1.next=p2
            return link1
        if p1.data < p2.data and p1.next.data>p2.data:
            px=p1.next
            py=p2.next
            p1.next=p2
            p2.next=px
            p2=py
            p1=px
        elif p1.next.data<p2.data:
            p1=p1.next
    return link1

def fenzu(group):
    n=len(group)
    if n==1:
        return group[0]
    elif n==2:
        return hebing(group[0],group[1])
    else:
        return hebing(fenzu(group[:n//2]),fenzu(group[n//2:]))
l1,l2,l3=[1,3,5,9],[0,2,4,6,8,10],[3.1,5.5,15,46]
link1,link2,link3=linklist(),linklist(),linklist()
link1.init(l1)
link2.init(l2)
link3.init(l3)
fenzu([link1,link2,link3]).show()

原文地址:https://www.cnblogs.com/offline-ant/p/9374606.html

时间: 2024-08-02 12:14:15

leetcode python 012 hard 合并k个有序链表的相关文章

[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 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

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

一.题目要求: 将K个有序链表合并为一个有序链表 二.实现方法: 方法一:利用最小堆方法 用一个大小为K的最小堆(用优先队列+自定义降序实现)(优先队列就是大顶堆,队头元素最大,自定义为降序后,就变成小顶堆,队头元素最小),先把K个链表的头结点放入堆中,每次取堆顶元素,然后将堆顶元素所在链表的下一个结点加入堆中. 整体测试代码: #include <vector> #include <iostream> #include<queue> #include<set&g

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

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

LeetCode 第23题 合并K个排序链表

/* 23. 合并K个排序链表 合并 k 个排序链表,返回合并后的排序链表.请分析和描述算法的复杂度. 示例: 输入:[ 1->4->5, 1->3->4, 2->6]输出: 1->1->2->3->4->4->5->6 */ /** * Definition for singly-linked list. public class ListNode { int val; ListNode next; ListNode(int * x

LeetCode 第21题 合并两个有序链表

/*将两个有序链表合并为一个新的有序链表并返回.新链表是通过拼接给定的两个链表的所有节点组成的. 示例: 输入:1->2->4, 1->3->4输出:1->1->2->3->4->4 Definition for singly-linked list. public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } */ 1 class Solutio

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

每天AC系列(九):合并K个排序链表

1 题目 LeetCode第23题,合并k个有序的链表. 2 暴力法 直接遍历所有链表,取出所有节点的值,用数组存储,非降序排序,然后创建一个新链表用头插法依次插入节点. List<Integer> s = new ArrayList<>(); for(ListNode x:lists) { while(x != null) { s.add(x.val); x = x.next; } } s.sort((a,b) -> {return a.compareTo(b);}); L