常用算法

一、算法（Algorithm）：一个计算过程，解决问题的方法

二、衡量程序好坏的标准可以通过时间复杂度和空间复杂度

三、时间复杂度：是用来估计算法运行时间的一个式子（单位）。

一般来说，时间复杂度高的算法比复杂度低的算法慢。

常见的时间复杂度（按效率排序） O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n2logn)<O(n3)

不常见的时间复杂度（看看就好） O(n!) O(2n) O(nn) …

如何一眼判断时间复杂度？

循环减半的过程O(logn)

几次循环就是n的几次方的复杂度

四、空间复杂度：用来评估算法内存占用大小的一个式子

空间换时间

五、排序算法

1、冒泡排序

# 时间复杂度是： O(n^2)
# 空间复杂度是： O(1)
def BubbleSort(li):
    for i in range(len(li)):    # i = 0
        flag = True
        for j in range(len(li) - i - 1):   # j = 0, j = 1, j =2
            if li[j] > li[j+1]:            # li[0]=1 > li[1]=2 | li[1]=2 > li[2]=3 | li[2] > li[3]
                li[j], li[j+1] = li[j+1], li[j]
                flag = False
        if flag:
            return None

2、选择排序

# 时间复杂度是：O(n^2)
# 空间复杂度是：O(1)
def SelectSort(li):
    for i in range(len(li)):
        minLoc = i
        for j in range(i + 1, len(li)):
           if li[j] < li[minLoc]:
                li[j], li[minLoc] = li[minLoc], li[j]

3、插入排序

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

        li[j + 1] = tmp  # li[0] = tmp = 4

4、快速排序

# 时间复杂度：O(nlogn)
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:
        mid = partition(li, left, right)  # O(n)
        Quick_Sort(li, left, mid-1)      #  O(logn)
        Quick_Sort(li, mid+1,right)

5、归并排序

# 时间复杂度：O(nlogn)
# 空间复杂度：O(n)
# python 底层 sorted()函数， 采用的排序算法是 TimSorted 包含了归并排序和插入排序
# TimSorted 的时间复杂度是：O(nlogn)
def merge(li, low, mid, high):
    i = low
    j = mid + 1
    ltmp = []
    while i <= mid and j <= high:
        if li[i] <= li[j]:
            ltmp.append(li[i])
            i += 1
        else:
            ltmp.append(li[j])
            j += 1
    while i <= mid:
        ltmp.append(li[i])
        i += 1
    while j <= high:
        ltmp.append(li[j])
        j += 1
    li[low:high+1] = ltmp

def mergeSort(li, low, high):
    if low < high:
        mid = (low+high) // 2
       # 分解
        mergeSort(li, low, mid)  ### O(logn)
        mergeSort(li, mid+1, high)
        print('分解后：',li[low:high + 1])
        # 合并
        merge(li, low, mid, high)
        print('合并后：', li[low:high + 1])