python常用算法了解

Posted 2021-11-29 mr-allen

这里从个人角度，总结下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)