歸併排序是一種穩定的排序，採用分而治之策略，可以用於順序儲存結構，也易於在鍊錶上實現。其原理如下圖：
演算法時間複雜度為 o（nlogn），空間複雜度為 o（n）。
def mergesort(seq):
if len(seq)<=1:
return seq
mid=int(len(seq)/2)
left=mergesort(seq[:mid])
right=mergesort(seq[mid:])
return merge(left,right)
def merge(left,right):
result=
i,j=0,0
while i輸出：
[5, 6, 7, 8]
# definition of listnode
class listnode(object):
def __init__(self, val, next=none):
self.val = val
self.next = next
class solution:
"""@param: head: the head of linked list.
@return: you should return the head of the sorted linked list, using constant space complexity.
"""# 歸併法
def sortlist(self, head):
# write your code here
if head is none or head.next is none:
return head
pre = head
slow = head # 使用快慢指標來確定中點
fast = head
while fast and fast.next:
pre = slow
slow = slow.next
fast = fast.next.next
left = head
right = pre.next
pre.next = none # 從中間打斷鍊錶
left = self.sortlist(left)
right = self.sortlist(right)
return self.merge(left,right)
def merge(self, left, right):
pre = listnode(-1)
first = pre
while left and right:
if left.val < right.val:
pre.next = left
pre = left
left = left.next
else:
pre.next = right
pre = right
right = right.next
if left:
pre.next = left
else:
pre.next = right
return first.next
node1 = listnode(4)
node2 = listnode(3)
node3 = listnode(2)
node4 = listnode(1)
node1.next = node2
node2.next = node3
node3.next = node4
s = solution()
result = s.sortlist(node1)
while (result != none):
print(result.val)
result = result.next
123
4
佇列（陣列實現和鍊錶實現）
1.概念 具有一定操作約束的線性表 2.特點 1 只能在一端插入 入隊 另一端刪除 出隊 2 先進先出。3.儲存實現方式 陣列 鍊錶。4.基本操作 1.陣列實現 迴圈陣列 注意 1 普通的順序儲存的陣列用來實現佇列時，存在乙個問題 當rear 記錄隊尾的變數 到達maxsize 1時，不能確定佇列是...
佇列的陣列和鍊錶實現
1.佇列是先入先出額資料結構，它的實現可以用陣列，也可以用鍊錶。用陣列實現鍊錶時，需要預先分配陣列的大小，用front和rear下標分別表示隊頭元素下標和隊尾元素下標，插入乙個元素時，使隊尾的下標rear加1，刪除乙個元素時，front下標加1，判斷是否為空的佇列只要判斷front和rear是否相等...
陣列和鍊錶實現Stack
需要先開闢一定的理論空間capacity的陣列 當實際空間size大於理論空間capacity時，需要重新分配空間大小 通過size來指向棧頂 壓棧就是將新的數值放在size處，然後size 出棧就是將size處的數值返還，size pragma once 棧的兩種實現方法之陣列實現 templat...