python經常使用算法瞭解

這裏從我的角度，總結下python經常使用算法，不羅嗦，直接看代碼（文字解釋及推到過程網上有不少，你們能夠經過度娘瞭解）

如下排名僅從寫代碼人本身習慣的順序！

NO.1 二分查找

import time

# 時間裝飾器
def cal_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        # print("%s running time: %s secs." % (func.__name__, start_time - end_time))
        print("%s 函數執行時間是: %s 秒" % (func.__name__, start_time - end_time))
        return result

    return wrapper


@cal_time
def bin_search(data_list, val):
    # 開始位置：第0個位置
    low = 0
    # 結束位置：最後一個位置
    high = len(data_list) - 1
    # 循環判斷
    while low <= high:
        # 獲取中間位置,這裏須要整除//
        mid = (low + high) // 2
        # 判斷中間索引對應的數字是否是查找的數字
        if data_list[mid] == val:
            #print(data_list[mid])
            return mid
        # 若是中間索引對應的數字在查找數字的左邊，則 low = mid + 1
        elif data_list[mid] < val:
            low = mid + 1
        # 若是中間索引對應的數字在查找數字的右邊，則  high = mid - 1
        elif data_list[mid] > val:
            high = mid - 1
    return


if __name__ == '__main__':
    data_list = list(range(1,10000))
    ret = bin_search(data_list, 6666)
    print(ret)

NO.2 冒泡

import random

def buble_sort1(data_list):
    # i 是已經執行的趟數 i=n-1 ,n是列表中數字總個數=len(data_list)
    for i in range(len(data_list) - 1):
        # j是等待執行的趟數
        for j in range(len(data_list) - 1 - i):
            if data_list[j] > data_list[j + 1]:
                data_list[j], data_list[j + 1] = data_list[j + 1], data_list[j]

#優化版本
#若是排了一半，後面數據不須要排序的狀況
def buble_sort2(data_list):
    # i 是已經執行的趟數 i=n-1 ,n是列表中數字總個數=len(data_list)
    for i in range(len(data_list) - 1):
        exchange = False
        # j是等待執行的趟數
        for j in range(len(data_list) - 1 - i):
            if data_list[j] > data_list[j + 1]:
                data_list[j], data_list[j + 1] = data_list[j + 1], data_list[j]
                #若是進行交換，則修改變量
                exchange = True
        #若是沒發生交換
        if not exchange:    #exchange = False
            break

if __name__ == '__main__':
    data_list = list(range(1001))
    # 打亂數字順序
    random.shuffle(data_list)
    # print(data_list)
    buble_sort2(data_list)
    print(data_list)

NO.3 快排

import random


def quick_sort_x(data, left, right):
    #判斷left right，若是相等，就結束函數
    if left < right:
        #mid是tmp的索引位置
        mid = partition(data, left, right)
        #左邊遞歸
        quick_sort_x(data, left, mid - 1)
        #右邊遞歸
        quick_sort_x(data, mid + 1, right)

def partition(data, left, right):
    #把data[left]賦值給了tmp,因此如今left的位置是空的
    tmp = data[left]
    # 判斷left right，若是相等，就結束函數
    while left < right:
        #先從右邊開始找
        #右邊尋找的是比tmp小的數，因此，若是找到比tmp大的數，進行循環
        while left < right and data[right] >= tmp:
            right -= 1
        # 把右邊找到的數賦值給左邊，右邊出現了空位置
        # 如今指針如今到了左邊
        data[left] = data[right]
        # 左邊尋找的是比tmp大的數，因此，若是找到比tmp小的數，進行循環
        while left < right and data[left] <= tmp:
            left += 1
        # 把左邊找到的數賦值給右邊，左邊出現了空位置
        # 如今指針如今到了右邊
        data[right] = data[left]
    #把tmp賦值給左邊空出的位置
    data[left] = tmp
    # 返回tmp的下角標（索引）
    return left


if __name__ == '__main__':
    data = list(range(1000))
    random.shuffle(data)
    print('排序前：',data)
    quick_sort_x(data,0,len(data)-1)
    print('排序後：',data)

NO.4 插入排序

import random


def insert_sort(data_list):
    for i in range(1, len(data_list)):
        temp = data_list[i]
        j = i - 1
        while j >= 0 and data_list[j] > temp:
            data_list[j + 1] = data_list[j]
            # 少了一個數
            j = j - 1
        data_list[j + 1] = temp


if __name__ == '__main__':
    data_list = list(range(1001))
    # 打亂數字順序
    random.shuffle(data_list)
    # print(data_list)
    insert_sort(data_list)
    print(data_list)

NO.5 選擇排序

import random


def select_sort(data_list):
    for i in range(len(data_list) - 1):
        # 假設第i個索引對應的值最小
        min_index = i
        # 第i個索引對應的值 和 從第i+1個索引開始的數進行循環比較
        for j in range(i + 1, len(data_list)):
            if data_list[min_index] > data_list[j]:
                min_index = j
        # 注意：這時 data_list[min_index] = data_list[j]
        data_list[i], data_list[min_index] = data_list[min_index], data_list[i]


if __name__ == '__main__':
    data_list = list(range(1001))
    # 打亂數字順序
    random.shuffle(data_list)
    select_sort(data_list)
    print(data_list)

NO.6 堆排序

import random

def sift(data,low,high):
    i = low
    j = 2 * i + 1
    tmp = data[i]
    while j <= high:
        #if j < high and data[j] < data[j + 1]:
        if j < high and data[j] > data[j + 1]:
            j = j + 1
        #if tmp < data[j]:
        if tmp > data[j]:
            data[i] = data[j]
            i = j
            j = 2 * i + 1
        else:
            break
    data[i] = tmp


def heap_sort(data):
    n = len(data)  # 把堆的長度存一下

    # 建堆：
    # 從最後一個有孩子的父親開始，直到第一個領導【(n // 2 - 1,-1)--->範圍，最後一個 -1是步長】
    # 實驗證實：最後一個有孩子的父親的位置是n // 2 - 1
    for i in range(n // 2 - 1, -1,-1):

    # 每次調整這個領導（'i'）所在的堆【每一個小堆作調整】,調整到堆的最後，因此 high = n-1
    # 堆就建好了
        sift(data, i, n - 1)

    # 挨個出數：
    for i in range(n - 1, -1):
        # i 是堆的最後一個元素
        # 領導退休，平民上位
        data[0], data[i] = data[i], data[0]
        # 調整出新領導
        sift(data, 0, i - 1)


if __name__ == '__main__':
    data = list(range(1000))
    random.shuffle(data)
    print('排序前：',data)
    heap_sort(data)
    print('排序後：',data)