算法基础

一、时间复杂度

1.时间复杂度是用来估算算法运行时间的一个式子。（单位）

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

3.常见的时间复杂度（按效率排序）：

O(1)<O(logn)<O(n)<O(nlogn)<O(n²)<O(n²logn)<O(n³)

如何一眼判断时间复杂度：（大部分情况下）

1.循环减半的过程——O(logn)

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

 

二、空间复杂度

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

——空间换时间

 

三、常见算法

1.查找

二分查找：

1.1（代码复杂度O(logn)）

def search_l(data_set,value):
    low = 0
    high = len(data_set) - 1
    while low <= high:
        mid = (low + high) // 2
        if data_set[mid] == value:
            return mid
        elif data_set[mid] < value:
            low = mid+1
        else:
            high = mid -1
    return None

　　

1.2 递归版本（代码复杂度O(n)）

def search_li(data_set,value,low,high):
    while low <= high:
        mid = (low + high) // 2
        if data_set[mid] == value:
            return mid
        elif data_set[mid] < value:
            return search_li(data_set,value,low+1,high)
        else:
            return search_li(data_set, value, low, high-1)
    return None

　　

 2.排序：

2.1 lowB三人组（冒泡、选择、插入）

冒泡（O(n²),速度慢）：用for循环遍历，相邻的2个数进行对比，大的总是往上推。遍历一趟有序区增加一个数，第一趟完成最大数永远在最上（最后），有几个数则遍历几趟，最后一个数时不需要再做调整，所以真实为len(li)-1趟。

def bubble_sort(li):
    for i in range(len(li)-1):  #i 指的是第几趟
        for j in range(len(li)-i-1): #j是指针，range中为每一趟指针最后指到的位置
            if li[j] > li[j + 1]:
                li[j],li[j+1] = li[j+1],li[j]

　　

选择排序(O(n²))：

思路：一趟遍历记录最小的数，放到第一个位置；

在一趟遍历记录剩余列表中最小的数，继续放置；......

问题：如何选出最小的数?

关键点：无序区，最小数的位置

def select_sort(li):
    for i in range(len(li) - 1):
        min_loc = i
        for j in range(i+1,len(li)):
            if li[j] < li[min_loc]:
                min_loc = j
        if min_loc != i:
            li[i],li[min_loc] = li[min_loc],li[i]

　　

插入排序(O(n²)：

思路：列表被分为有序区和无序区两个部分。最初有序区只有一个元素。

每次从无序区选择一个元素，插入到有序区的位置，直到无序区变空。

关键点：摸到的牌   手里的牌

def insert_sort(li):
    for i in range(1,len(li)):
        tmp = li[i]
        j = i - 1
        while j >= 0 and tmp < li[j]:
            li[j + 1] = li[j]
            j -= 1
        li[j + 1] = tmp

　　

2.2 快速排序：

好写的排序算法里最快的，快的排序算法里最好写的。

思路：取一个元素p(第一个元素)，使元素p归位；

列表被p分成两部分，左边的都比p小，右边的都比p大；

递归完成排序。

第一步：def quick_sort(data,left,right):

    if left < right:
        mid = partition(data,left,right)
        quick_sort(data,left,mid - 1)
        quick_sort(data,mid + 1,right)

最终：

def partition(data,left,right):
    tmp = data[left]
    while left < right:
        while left < right and data[right] >= tmp:
            right -= 1
        data[left] = data[right]
        while left < right and data[left] <= tmp:
            left += 1
        data[right] = data[left]
    data[left] = tmp
    return left

def quick_sort(data,left,right):
    if left < right:
        mid = partition(data,left,right)
        quick_sort(data,left,mid - 1)
        quick_sort(data,mid + 1,right)