python 實現經典算法

import time
start_time = time.clock()

list_ = [9, 2, 7, 4, 5, 6, 3, 8, 1]


"""
# 堆排序(通過不斷的構造最大堆來選出序列的最大值放到末尾)
# 最大堆調整：將堆的末端子節點調整，使得子節點永遠小於父節點。
# 建立最大堆：將堆所有數據重新排序。
# 堆排序：移除位在第一個數據的根節點，並做最大堆調整的遞歸運算。
import random


def max_heapify(heap, heapsize, root):
    # 最大堆調整
    left = 2 * root + 1
    right = left + 1
    larger = root
    if left < heapsize and heap[larger] < heap[left]:
        larger = left
    if right < heapsize and heap[larger] < heap[right]:
        larger = right
    if larger != root:
        heap[larger], heap[root] = heap[root], heap[larger]
        max_heapify(heap, heapsize, larger)


def build_max_heap(heap):
    # 構造一個堆，將堆中所有數據重新排序
    heapsize = len(heap)
    for i in range((heapsize - 2) // 2, -1, -1):
        max_heapify(heap, heapsize, i)


def heapsort(heap):
    # 將根節點去除與最后一位做對調，對前面len-1個節點繼續進行對調整過程。
    build_max_heap(heap)
    for i in range(len(heap) - 1, -1, -1):
        heap[0], heap[i] = heap[i], heap[0]
        max_heapify(heap, i, 0)
    return heap


if __name__ == '__main__':
    a = [30, 50, 57, 77, 62, 78, 94, 80, 84]
    print(a)
    heapsort(a)
    print(a)
    # b = [random.randint(1, 1000) for i in range(1000)]
    # print(b)
    # heapsort(b)
    # print(b)
# --------------------------------------------------------------

# 歸並排序
# 首先用分割的方法將這個序列分割成一個個已經排好序的子序列，然后
# 再利用歸並的方法將一個個的子序列合並成排序號的序列
def merge(left, right):
    result = []
    while left and right:
        result.append(left.pop(0)) if left[0] < right[0] else result.append(right.pop(0))
    while left:
        result.append(left.pop(0))
    while right:
        result.append(right.pop(0))
    return result


def mergesort(l):
    if len(l) < 2:
        return l
    mid_index = len(l) // 2
    left = mergesort(l[:mid_index])
    right = mergesort(l[mid_index:])
    return merge(left, right)


print(mergesort(list_))
# --------------------------------------------------------------

# 希爾排序 將序列分割成若干子序列（由相隔某個增量的元素組成的）分別進行直接插入排序接着依次縮小增量繼續進行排序，待整個序列基本有序時，再對全體元素進行插入排序。
def shell_sort(l):
    n = len(l)
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            temp = l[i]  # 每個步長進行插入排序
            j = i
            # 插入排序
            while j >= gap and l[j - gap] > temp:
                l[j] = l[j - gap]
                j -= gap
            l[j] = temp
        gap = gap // 2
    return l


print(shell_sort(list_))
# --------------------------------------------------------------

# 插入排序 
# 從索引1開始，一次與其左邊的數相比較，若比自己大則插入並刪除自己。
def insertsort(l):
    len_ = len(l)
    for i in range(1, len_):
        for j in range(i):
            if l[j] > l[i]:
                l.insert(j, l[i])
                l.pop(i+1)
                break
    return l


print(insertsort(list_))
# --------------------------------------------------------------

# 快速排序
# 選定一個基數如第一個元素
# 將比基數小的和比基數大的元素分別放在新列表里並按順序排列相加
# 遞歸直到新列表元素只有一個
def quicksort(l):
    len_ = len(l)
    if len_ < 2:
        return l
    else:
        pivot = l[0]
        less = [i for i in l[1:] if i <= pivot]
        greater = [j for j in l[1:] if j > pivot]
        print(less, greater)
        return quicksort(less) + [pivot] + quicksort(greater)


print(quicksort(list_))
# --------------------------------------------------------------

# 選擇排序
# 將第一個數與右邊數的最小值相比較，若本身較大則與最小值調換位置
# 依次遍歷即可
def selectsort(l):
    len_ = len(l)
    for i in range(len_ - 1):
        for j in range(i+1, len_):
            min_ = min(l[j:])
            min_index = l.index(min_)
            if l[i] > min_:
                l[i], l[min_index] = l[min_index], l[i]
    return l

# 上述選擇排序代碼存在問題，這次復習自己重寫時發現對重復數字處理不對，同時循環也有問題。以下是更改后代碼：
def selectsort(l):
    length = len(l)
    for i in range(length-1):
        m = min(l[i+1:])  # 當前數字右邊的數字列表中的最小數
        j = l[i+1:].index(m) + i + 1  # m的索引，防止重復數字的干擾 
        if l[i] > m:
            l[i], l[j] = l[j], l[i]
    return l

print(selectsort(list_)) 
# --------------------------------------------------------------

# 冒泡排序
# 從索引0開始依次本身和右邊的元素，若右邊小則調換位置，來取得最大值
# 然后依次循環把較大的輪換到右邊
def bubblesort(l):
    len_ = len(l)
    for i in range(len_ - 1):
        for j in range(len_ - i - 1):
            if l[j] > l[j+1]:
                l[j], l[j+1] = l[j+1], l[j]
    return l


print(bubblesort(list_))
"""

end_time = time.clock()
print(end_time - start_time)

目前對於堆排序還不太理解，以備后續重溫復習。