合併k個排序鍊錶（Python實現）

題目描述：

合併 k 個排序鍊錶，返回合併後的排序鍊錶。請分析和描述演算法的複雜度。

示例:輸入:

[1->4->5,

1->3->4,

2->6

]輸出: 1->1->2->3->4->4->5->6

思路要點：

1、匯入鍊錶模組（自定義）

2、使用python自帶的二分排序庫進行排序，可降低時間複雜度

**：

import chaintable as c

import bisect
class solution(c.chaintable):
def __init__(self,lists):
self.lists=lists
self.result=self.mergeklists(self.lists)
def mergeklists(self,lists):
sort_lst=
while true:
flag=0
for i in lists:
if i.isempty():
continue
flag=1
t=i.getitem(0)
bisect.insort(sort_lst,t)
i.delete(0)
if flag==0:
break
sort_chaintable=c.chaintable()
for i in sort_lst:
return sort_chaintable
if __name__=='__main__':
lists=['145','134','26']
for i in range(len(lists)):
temp=lists[i]
lists[i]=c.chaintable()
for j in temp:
print('原鍊錶：\n')
print(lists)
print('\n')
solution=solution(lists)
lst=solution.result
print('排序後：\n')
print(lst)

#用python實現資料結構鍊錶

class node:
'''定義節點類
data:節點儲存的資料
next_node:下乙個節點物件
'''def __init__(self,data,pnext=none):
self.data=data
self.next_node=pnext
def __repr__(self):
'''定義node的字元輸出
print為輸出data
'''return str(self.data)
'''鍊錶類：
屬性：煉表頭：head
鍊錶長度：length
方法：以下
'''class chaintable:
def __init__(self):
self.head=none
self.length=0
'判斷是否為空列表'
def isempty(self):
return self.length==0
'在鍊錶尾增加乙個節點'
item = none
if isinstance(dataornode, node):
item = dataornode
else:
item = node(dataornode)
if not self.head:
self.head=item
self.length+=1
else:
node=self.head
'迴圈至最後乙個節點'
while node.next_node:
node=node.next_node
node.next_node=item
self.length+=1
'刪除乙個節點'
def delete(self,index):
if self.isempty():
print("sorry,the chain table is empty")
return
if index<0 or index>=self.length:
print("error:out of index")
return
if index==0:
self.head=self.head.next_node
self.length-=1
return
index=0
node=self.head
pre_node=self.head
while node.next_node and index=self.length:
print("error:out of index")
return
index=0
node=self.head
while node.next_node and index=self.length:
print("error:out of index")
return
index=0
node=self.head
while node.next_node and index=self.length:
print("error:out of index")
return
item=none
if isinstance(dataornode,node):
item=dataornode
else:
item=node(dataornode)
if index==0:
item.next_node=self.head
self.head=item
self.length+=1
return
index=0
node=self.head
prev=self.head
while node.next_node and index'
node=node.next_node
else:
nlist+=str(node.data)
node=node.next_node
return nlist
def __getitem__(self, ind):
if self.isempty() or ind < 0 or ind >= self.length:
print("error: out of index")
return
return self.getitem(ind)
def __setitem__(self, ind, val):
if self.isempty() or ind < 0 or ind >= self.length:
print("error: out of index")
return
self.update(ind, val)
def __len__(self):
return self.length

原鍊錶：

[1->4->5, 1->3->4, 2->6]

排序後：

1->1->2->3->4->4->5->6

合併k個排序鍊錶

合併k個排序鍊錶，並且返回合併後的排序鍊錶。嘗試分析和描述其複雜度。樣例 給出3個排序鍊錶 2 4 null,null,1 null 返回 1 2 4 null 兩兩合併 合併ab得到c 合併cd得到e definition for listnode.public class listnode pu...

合併K個排序鍊錶

從21.合併兩個有序鍊錶的基礎上，我們已經能夠解決兩個有序鍊錶的問題，現在是k個有序鍊錶，我們可以將第一二個有序鍊錶進行合併，然後將新的有序鍊錶再繼續跟第三個有序鍊錶合併，直到將所有的有序鍊錶合併完成。這樣做思路上是可行的，但是演算法的時間複雜度將會很大，具體就不計算了。有興趣的自己計算下。根據思路...

合併K個排序鍊錶

題目 合併 k 個排序鍊錶，返回合併後的排序鍊錶。請分析和描述演算法的複雜度。示例 輸入 1 4 5,1 3 4,2 6 輸出 1 1 2 3 4 4 5 6 思路 設定乙個堆，每次把每個鍊錶的頭結點放入堆中。記錄每個節點的值與在原陣列中的位置，便於鍊錶往下走。彈出堆中最小值，把最小值所在位置的陣列...