Python 19 算法

一、基本概念

时间复杂度：是用来估计算法运行时间的单位，一般来说时间复杂度高的算法运行速度慢。常见的时间复杂度排序： 1<logn<n<nlogn<n**2<n**2logn<n**3

空间复杂度：用来评估算法所占内存大小

递归的两个特点：调用自身、结束条件

二、二分查找

方式一：非递归

#方式一：非递归
def half_search1(li, val):
    start = 0
    end = len(li) - 1
    while start <= end:
        half = (start + end) // 2
        if li[half] > val:
            end = half - 1
        elif li[half] < val:
            start = half + 1
        else:
            return half
    return

方式二：递归

#方式二：递归
def half_search2(li, val, start, end):
    if start <= end:
        half = (start + end) // 2
        if li[half] > val:
            end = half - 1
            return half_search2(li, val, start, end)
        elif li[half] < val:
            start = half + 1
            return half_search2(li, val, start, end)
        else:
            return half

一般可以不用递归实现的就不使用递归

三、排序

（1）基本排序

1、冒泡排序

冒泡排序是从第一个数开始，依次与下一个数进行比较，如果前一个数大于后一个数，则交换位置，这样每一趟都把无序区最大的数调换到有序区开头。

def bubble_sort(li):
    for i in range(len(li)-1):
        for j in range(len(li)-1-i):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]
    return li

2、选择排序

选择排序是每次遍历无序区，找到无序区中的最小值，放到有序区的最后。

def choose_sort(li):
    for i in range(len(li)-1):
        min_index = i
        for j in range(i,len(li)):
            if li[j] < li[min_index]:
                min_index = j
        li[i], li[min_index] = li[min_index], li[i]
    return li

3、插入排序

插入排序是依次取出一个无序区的数，放在有序区第一个比他小的数右边。

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

（2）升级排序

1、快速排序

def quick_sort(li, start, end):
    if start < end:
        md = partition(li, start, end)
        quick_sort(li, start, md-1)
        quick_sort(li, md+1, end)
    return li

def partition(li, start, end):
    val = li[start]
    while start < end:
        while start < end and li[end] >= val:
            end -= 1
        li[start] = li[end]
        while start < end and li[start] <= val:
            start += 1
        li[end] = li[start]
    li[start] = val
    return start

2、堆排序

3、归并排序