python3 實現經典的排序與搜索算法

插入算法，最優時間複雜度：O(n), 最壞時間複雜度：O(n^2).
   算法原理：從無序數列中選一個元素插入到有序的子序列中去，得到一個有序的、元素加一的子序列，直到整個無序數列的元素爲0，則整個序列全部有序。
   算法實現：

def insert_sort(eg_list):
    for i in range(1, len(eg_list)):
        for j in range(i, 0, -1):
            if eg_list[j] < eg_list[j-1]:
                eg_list[j], eg_list[j-1] = eg_list[j-1], eg_list[j]
eg_list = [32, 3, 5, 67, 87, 4, 23, 98, 99, 100]   
insert_sort(eg_list)
print(eg_list)             

選擇排序：在無序數列中找到最小元素，存放在數列的起始位置，然後從剩餘未排序元素中繼續尋找最小元素，放到已排序序列的末尾。以此類推，直到所有元素排序完畢。
   算法實現：

def select_sort(eg_list):
    for j in range(len(eg_list)-1)
        min_index = j
        for i in range(j+1, len(eg_list)):
            if eg_list[min_index] > eg_list[i]
                min_index = i
        eg_list[j], eg_list[min_index] = eg_list[min_index], eg_list[j]

list = [5, 89, 46, 98, 78, 76, 45, 23, 99, 100]
select_sort(list)
print(list) 

快速排序算法：最優時間複雜度：O(nlogn), 最壞時間複雜度：O(N^2)
   算法實現：

def quick_sort(eg_list, first, last):
    if first >= last:
        return
    mid_value = eg_list[first]
    low = first
    high = last
    while low < high:
        while low < high and eg_list[high] >= mid_value:
               high -= 1
        eg_list[low] = eg_list[high]
        
        while low < high and eg_list[low] < mid_value:
            low += 1
        eg_list[high] = eg_list[low]

    eg_list[low] = mid_value

    quick_sort(eg_list, first, low-1)

    quick_sort(eg_list, low+1, last)

list = [23, 4, 56, 78, 98, 45, 32, 1, 34, 7, 8, 99, 100]
print(list)
quick_sort(list, 0, len(list)-1)
print(list)

冒泡排序：重複地走訪過要排序的元素列，依次比較兩個相鄰的元素，如果他們的順序（如從大到小、首字母從A到Z）錯誤就把他們交換過來。走訪元素的工作是重複地進行直到沒有相鄰元素需要交換，也就是說該元素已經排序完成。
算法實現：

def bubble_sort(eg_list):
    n = len(eg_list)
    for j in range(n-1):
        for i in range(0,n-1-j):
        # 上面兩個for循環嵌套相當於：for j in range(len(eg_list)-1, 0, -1).
            if eg_list[i] > eg_list[i+1]:
                eg_list[i], eg_list[i+1] =eg_list[i+1], eg_list[i]

list = [34, 53, 23, 12, 21,78, 76, 65, 43, 95, 100]
print(list)
bubble_sort(list)
print(list)

希爾排序：希爾排序(Shell’s Sort)是插入排序的一種又稱“縮小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一種更高效的改進版本。希爾排序是非穩定排序算法。希爾排序屬於插入類排序,是將整個有序序列分割成若干小的子序列分別進行插入排序。
   排序過程：先取一個正整數d1<n，把所有序號相隔d1的數組元素放一組，組內進行直接插入排序；然後取d2<d1，重複上述分組和排序操作；直至di=1，即所有記錄放進一個組中排序爲止。

二分查找算法：二分查找也稱折半查找（Binary Search），它是一種效率較高的查找方法。但是，折半查找要求線性表必須採用順序存儲結構，而且表中元素按關鍵字有序排列。
查找過程：首先，假設表中元素是按升序排列，將表中間位置記錄的關鍵字與查找關鍵字比較，如果兩者相等，則查找成功；否則利用中間位置記錄將表分成前、後兩個子表，如果中間位置記錄的關鍵字大於查找關鍵字，則進一步查找前一子表，否則進一步查找後一子表。重複以上過程，直到找到滿足條件的記錄，使查找成功，或直到子表不存在爲止，此時查找不成功。
算法實現：

def binary_search(eg_list, item):
    n = len(eg_list)
    if n > 0:
        mid = n//2
        if eg_list[mid] == item:
            return True
        elif item < eg_list[mid]:
            return binary_search(eg_list[:mid], item)
        else:return binary_search(eg_list[mid+1:], item)
    return False

list = [3, 4, 13, 23, 45, 56, 78, 96 ,99 ,100]
print(binary_search(list, 96))