算法

时间复杂度

需求：某段程序执行的时间
传统做法：
    import time
    start = time.time()
    程序
    end = time.time()
    end - start
上述做法的前提是：
    程序所依赖的硬件环境是要一致的
    因此，我们不能够单纯的使用time这个模块计算程序的执行时间
时间复杂度：
    用来估算程序执行次数的一个标准，使用O()
如何一眼判断时间复杂度
    循环减半的过程O(logn)
    几次循环就是n的几次方的复杂度

冒泡排序

# 时间复杂度:O(n^2) 空间复杂度:O(1)
def bubble_sort(li):
    for i in range(len(li) - 1):
        flag = False
        for j in range(len(li) - 1 - i):
            if li[j] > li[j + 1]:
                li[j], li[j + 1] = li[j + 1], li[j]
                flag = True
        if not flag:
            return

选择排序

# 时间复杂度:O(n^2) 空间复杂度:O(1)
def select_sort(li):
    for i in range(len(li) - 1):
        min_num = i
        for j in range(i + 1, len(li)):
            if li[min_num] > li[j]:
                li[min_num], li[j] = li[j], li[min_num]

插入排序

# 时间复杂度:O(n^2)空间复杂度:O(1)
def insert_sort(li):
    for i in range(1, len(li)):
        tmp = li[i]
        j = i - 1
        while j >= 0 and li[j] > tmp:
            li[j + 1] = li[j]
            j = j - 1
        li[j + 1] = tmp

快速排序

# 时间复杂度:O(n log n)
def partition(li, left, right):
    tmp = li[left]
    while left < right:
        while left < right and li[right] >= tmp:
            right = right - 1
        li[left] = li[right]
        while left < right and li[left] <= tmp:
            left = left + 1
        li[right] = li[left]

    li[left] = tmp
    return left


def quick_sort(li, left, right):
    if left < right:
        middle = partition(li, left, right)  # O(n)
        quick_sort(li, left, middle - 1)  # O(log n)
        quick_sort(li, middle + 1, right)  # O(log n)

归并排序

# 时间复杂度O(n log n) 空间复杂度:O(n)
def merge(li, low, middle, high):
    i = low
    j = middle + 1
    tmp = []
    while i <= middle and j <= high:
        if li[i] < li[j]:
            tmp.append(li[i])
            i = i + 1
        else:
            tmp.append(li[j])
            j = j + 1
    while i <= middle:
        tmp.append(li[i])
        i = i + 1
    while j <= high:
        tmp.append(li[j])
        j = j + 1
    li[low:high + 1] = tmp


def merge_sort(li, low, high):
    if low < high:
        middle = (low + high) // 2
        merge_sort(li, low, middle)
        merge_sort(li, middle + 1, high)
        print("归并前:", li[low:high + 1])
        merge(li, low, middle, high)
        print("归并后:", li[low:high + 1])

计数排序

def count_sort(li: list):
    count = [0 for i in range(11)]
    for i in li:
        count[i] += 1
    li.clear()
    for n, num in enumerate(count):
        print(n, num)
        for i in range(num):
            li.append(n)