Python数据结构与算法笔记-基本算法

算法

递归

def func1(x):
    if x>0:
        print(x)
        func1(x-1)

汉诺塔问题解决

def hanoi(n, a, b, c):
    '''
    :param n: d多少个盘子
    :param a: 起始柱子
    :param b: 中间柱子
    :param c: 目的柱子
    :return:
    '''
    if n > 0:
        hanoi(n - 1, a, c, b)
        print('moving %s from %s to %s' % (n-1,a, b))
        hanoi(n - 1, b, a, c)

hanoi(3, 'a', 'b', 'c')

查找

列表查找

内置函数index(),线性查找方法

顺序查找

也叫线性查找，从列表第一个元素开始，顺序进行搜索，直到找到元素或搜索到列表最后一个元素为止

def linear_search(li, val):
    for ind , v in enumerate(li):
        if v == val:
            return ind
        else:
            return None

二分查找

又叫折半查找，从有序列表的初始候选区li[0:n]开始，通过对待查找的值与候选区中间值的比较，可以使候选区减少一半；

def cal_time(func):
    def wrapper(*args, **kwargs):
        t1 = time.time()
        res = func(*args, **kwargs)
        t2 = time.time()
        print("%s running time : %s secs" % (func.__name__, t2 - t1))
        return res
    return wrapper

@cal_time
def binary_search(li,val):
    left = 0
    right = len(li)-1
    while left <=right:  # 候选区有值
        mid = (left+right)//2
        if li[mid] == val:
            return mid
        elif li[mid] > val: # 待查找的值在mid 的左侧
            right = mid-1
        else:  # li[mid] < val 待查找的值在mid 的右侧
            left = mid +1
    else:
        return None
        
li = list(range(0,10))

binary_search(li,7)

排序

冒泡排序（Bubble sort）

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

li = [random.randint(0,20) for i in range(20)]

bubble_sort(li)

如果想降序排列，将 > 改为 <

选择排序

def select_sort_simple(li):
    print(li)
    li_new = []
    for i in range(len(li)):
        min_val = min(li)
        li_new.append(min_val)
        li.remove(min_val)
    print(li_new)

li = [random.randint(0,20) for i in range(20)]

select_sort_simple(li)

插入排序

def insert_sort(li):
    print(li)
    for i in range(1,len(li)-1):
        tmp = li[i]   # 摸到手里的牌
        j = i -1
        while j>=0 and li[j]>tmp:
            li[j+1] = li[j]  # 手里的牌往回移动位置
            j-=1
        li[j+1] = tmp # 插入摸到的牌
    print(li)
    
li = [random.randint(0,30) for i in range(20)]

insert_sort(li)

NB排序

快速排序

def partition(li, left, right):
    tmp = li[left]
    while left < right:
        while left < right and li[right] >= tmp:  # 从右边找比tmp小的数
            right -= 1  # 往左走一步
        li[left] = li[right]  # 把右边的牌，放到左边的空位（空位是因为牌被挪到tmp上了）
        while left < right and li[left] <= tmp:  # 从左边找比tmp大的数
            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)  # 获得中间的坐标，同时将最左边移动到中间（左边都比他小，右边都比他大）
        _quick_sort(li, left, mid - 1)  # 左边切片，排序左边递归
        _quick_sort(li, mid + 1, right)  # 右边切片，排序右边递归


@cal_time
def quick_sort(li):  # 给递归函数套个马甲，就可以用装饰器了
    _quick_sort(li, 0, len(li) - 1)


li = list(range(20))
random.shuffle(li)
print(li)
quick_sort(li)
print(li)

问题
递归：会消耗相当一部分资源（无法解决），超过递归上限
解决递归上限问题：

import sys
sys.setrecursionlimit(1000)

最坏情况，O($nlo{g}_n$) 变成了 O($n^2$)