Python 简单算法

最新推荐文章于 2022-07-16 16:16:52 发布

玉荒吹笛

最新推荐文章于 2022-07-16 16:16:52 发布

阅读量213

点赞数

分类专栏： Python

本文链接：https://blog.csdn.net/weixin_42598585/article/details/96905740

版权

Python 专栏收录该内容

38 篇文章 4 订阅

订阅专栏

冒泡排序

思路：相邻两个换位置，每次不循环最后一个值

代码：

def sort(li):
    # 第一层循环用来循环次数
    for i in range(len(li)):
        # 第二层循环 寻找当前中最大的值，  
        # -1 是因为 要判断 当前索引和当前索引+1 后的索引所代表的值 的大小， 因此要防止 越界错误，所以进行 -1 操作
        for j in range(len(li)-i-1):
            # 如果 右边 比 左边的值大，二者调换位置
            if li[j]>li[j+1]:
                li[j],li[j+1] = li[j+1],li[j] 
    return li

if __name__ == "__main__":
    li = [1,2,3,4,5,3,2,1,4]
    print(sort(li))

选择排序

思路：分成无序区和有序区，并且记录最小值。

代码：

def sort(li):
    # 确定循环次数
    # -1 是因为当循环到最后一次的时候，就剩下 自己一个数，自己在和自己比 无意义
    for i in range(len(li)-1):
        # 记录最小值
        low = i
        # 记录无序区
        for j in range(i,len(li)):
            # 如果 记录最小值 大于 无序区的某个值
            if li[low] > li[j]:
                # 更换 记录最小值
                low = j
        # 如果 记录最小值 发生变化，则说明 索引 low 的值 要大于 索引 i 的值
        if low != i:
            # 调换其位置
            li[i],li[low] = li[low],li[j]
    return li


if __name__ == "__main__":
    li = [1,2,3,4,5,3,2,1,4]
    print(sort(li))

插入排序

思路：手里面的牌，和摸到的牌

代码：

def 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 = j -1
        # j 一直都是记录 比摸到的牌 小的 当前手里牌的位置，所以 j 要加 1 来存放 摸到的牌
        li[j+1] = tmp
    return li


if __name__ == "__main__":
    li = [1,2,3,4,5,3,2,1,4]
    print(sort(li))

快排：

思路：

两个指针
将列表分成两部分分别排序

版本一：

def sort_li(li,left,right):
    if left < right:
        # 获得 处于中间的 那个数的索引
        middle = get_middle(li,left,right)
        # 从 头 到 中间数 -1 分为左半部分
        sort_li(li,left,middle-1)
        # 从 中间数加一 到尾 分为右半部分
        sort_li(li,middle+1,right)
    return li


def get_middle(li,left,right):
    # 中间数，默认为 列表中第一个数
    tmp = data[left]
    while left < right:
        # 这里就是 右边的数一直都比 tmp 大，所以 right 的位置向 左边移动
        while left < right and li[right] >=tmp:
            right -= 1
        # 如果 出了这个循环，证明， li[right] < tmp, 交换位置
        li[left] = li[right]
        # 接下来 从左边开始 循环， 左边的数 要都小于 tmp
        while left < right and li[left] <= tmp:
            left += 1
        # 如果出了这个循环，证明 li[left] > tmp ,交换位置
        li[right] = li[left]
    # 将数放到 中间位置
    middle = left = right
    data[middle] = tmp
    return middle


if __name__ == "__main__":
    li = [1,2,3,2,1,2,3,4,5,34,23,4,5,3]
    print(sort_li,0,len(li))

版本二：

def quicksort(array):
    less = [];
    greater = [];

    if len(array) <= 1:
        return array
    pivot = array.pop()
    for x in array:
        if x <= pivot:
            less.append(x)
        else:
            greater.append(x)

    return quicksort(less) + [pivot] + quicksort(greater)

print(quicksort([1,3,2,4,3,5,4,3,2,1]))

二分查找

思路：分成一半进行查找

代码：

def select(li,value):
    low = 0
    zuihou = len(li)
    # 只要 左边指针小于 右边指针就循环
    while low < zuihou:
        # 取 左右两边的 中间索引
        middle = (low + zuihou) // 2
        # 如果 索引为中间的 值 大于 要查找的值
        if li[middle] > value:
            # 证明 要找的值可能位于 前半部分
            zuihou = middle -1
        # 如果 索引为中间的 值 小于 要查找的值
        elif li[middle] < value:
            # 证明 要找的值可能位于 后半部分
            low = middle + 1
        else:
            return middle
    return -1


if __name__ == "__main__":
    li = [1,2,3,4,5,6,7,8,9]
    print(select(li,5))

斐波那契

代码：

def get_fob(num):
    """
    循环的方式
    某个数 以内 所有的斐波那契数
    """
    a,b = 1,1
    while a < num:
        print(a, end="\t")
        a,b = b , a+b


def get_fob2(num):
    """
    递归的方式
    第 n 次的 斐波那契值 是多少
    """
    if num <= 1:
        return num
    return get_fob2(n-1) + get_fob2(n-2)


if __name__ == '__main__':
    # 100以内 所有的斐波那契数
    get_fob(100)
    # 第100次的 斐波那契值 是多少
    print(get_fob2(100))