• 插入排序

思想：將一組陣列分為有序組和待插入組兩組，將待插入組的元素依次與有序組元素比較找到合適的位置插入。

# -*- coding: UTF-8 -*-


def main():
    list_1 = [4, 6, 8, 4, 6, 1, 6, 8, 7, 4]
    for i in range(len(list_1)):
        for j in range(len(list_1) - i - 1):
            if list_1[i] > list_1[i + 1]:
                list_1[i], list_1[i + 1] = list_1[i + 1], list_1[i]
    print(list_1)


main()

 

• 希爾排序

思想：

這裡寫程式碼片

• 選擇排序

思想：每次選擇第n次大的數交換到序列的尾端，有n個元素進行排序就重複n次。

這裡寫程式碼片

• 氣泡排序

思想：比較相鄰兩個元素的大小，將大的交換到右邊，有n個元素進行排序就重複n次。

這裡寫程式碼片

• 歸併排序

這裡寫程式碼片

• 快速排序

這裡寫程式碼片

• 堆排序

# -*- coding: UTF-8 -*-


class PrioQueue:  # 優先佇列類
    def __init__(self, elist=[]):  # 新建
        self._elems = list(elist)
        if elist:
            self.buildheap()  # 新建堆

    def is_empty(self):  # 判空
        return not self._elems

    def peek(self):  # 檢視
        if self.is_empty():
            raise PrioQueueError('in peek')  # 為空時返回錯誤
        return self._elems[0]  #

    def enqueue(self, e):  # 入隊
        self._elems.append(None)  # 新增一個元素
        self.siftup(e, len(self._elems) - 1)  # 審查

    def siftup(self, e, last):  # 篩分
        elems, i, j = self._elems, last, (last - 1) // 2
        while i > 0 and e < elems[j]:
            elems[i] = elems[j]
            i, j = j, (j - 1) // 2
        elems[i] = e

    def dequue(self):  # 出隊
        if self.is_empty():
            raise PrioQueueError('in peek')  # 為空時返回錯誤
        elems = self._elems
        e0 = elems[0]
        e = elems.pop()
        if len(elems):  # 審查
            self.siftdown(e, 0, len(elems))
        return e0

    def siftdown(self, e, begin, end):  # 篩分
        elems, i, j = self._elems, begin, begin * 2 + 1
        while j < end:
            if j + 1 < end and elems[j + 1] < elems[j]:
                j += 1  # elems[j]不大於其兄弟節點的資料
            if e < elems[j]:  # e在三者中最小，已經找到其位置
                break
            elems[i] = elems[j]  # elems[j]在三者中最小，上移
            i, j = j, 2 * j + 1
        elems[i] = e

    def buildheap(self):  # 建堆
        end = len(self._elems)
        for i in range(end // 2, -1, -1):
            self.siftdown(self._elems[i], i, end)

    def heap_sort(elems):  # 堆排序
        def siftdown(elem, e, begin, end):  # 審查
            i, j = begin, begin * 2 + 1
            while j < end:
                if j + 1 < end and elems[j + 1] < elems[j]:
                    j += 1  # elems[j]不大於其兄弟節點的資料
                if e < elems[j]:  # e在三者中最小，已經找到其位置
                    break
                elems[i] = elems[j]  # elems[j]在三者中最小，上移
                i, j = j, 2 * j + 1
            elems[i] = e

        end = len(elems)
        for i in range(end // 2, -1, -1):  # 建堆，從i開始以end為建堆範圍的邊界
            siftdown(elems, elems[i], i, end)
        for i in range((end - 1), 0, -1):  # 逐個取出最小元素，將其積累到標的最後，放一個退一步
            e = elems[i]
            elems[i] = elems[0]
            siftdown(elems, e, 0, i)

 

• 基數排序

這裡寫程式碼片