Python经典算法

Autooooooo

发布于 2020-11-09 10:00:15

8550

发布于 2020-11-09 10:00:15

文章被收录于专栏：Coxhuang

算法实现

#0 GitHub

https://github.com/Coxhuang/Python-DataStructure

#1 环境

Python3.7.3

#2 开始

#2.1 斐波那契数列

GitHub

GitHub代码

问题描述
规律
代码实现

常规实现

def fib(max_val):
    a, b, n = 0, 1, max_val
    while n:
        print(a)
        a, b = b, a+b
        n -= 1
    return None
fib(10)

输出

生成器

def fib(max_val):
    a, b, n = 0, 1, max_val
    while n:
        yield a
        a, b = b, a+b
        n -= 1
    return None
for foo in fib(10):
    print(foo)

输出

递归

def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)
for foo in  range(10):
    print(fib(foo))

输出

#2.2 跳台阶

GitHub

GitHub代码

问题描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级(最多跳2级),求该青蛙跳上一个n级的台阶总共有多少种方法？

规律

如果台阶只有一级，只有一种走法；如果台阶有两级，走法有两种；如果台阶有N级，最后跳上第N级的情况，要么是从N-2级直接跳两级台阶，或者从第N-1级跳一级台阶，所以台阶有N级的方法数等于跨到N-2级台阶的方法数加上跨到N-1级台阶的方法数，即S(N)=S(N-1)+S(N-2),初始项为S(1)=1,S(2)=2,类似于斐波那契数列，只不过是初始项不同。

台阶数	方法
f(0)	0
f(1)	1
f(2)	2
f(3)	3
f(4)	5
f(5)	8
…	…

逻辑规律和斐波那契数列一致

代码实现

def fib(max_val):
    a, b, n = 0, 1, max_val
    while n:
        a, b = b, a+b
        n -= 1
    return b
n = 3 # 台阶数
ret = n if n <= 2 else fib(n)
print(ret)

#2.3 跳台阶(变态跳)

GitHub

GitHub代码

问题描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

规律

当跳1级台阶时，f(1) = 1;

当跳2级台阶时，f(2) = f(1) + 1 = 2;

当跳3级台阶时，f(3) = f(2) + f(1) + 1 = 4;

当跳4级台阶时，f(4) = f(3) + f(2) + f(1) + 1 = 8;

f(n-1) = f(n-2) +...+ f(2) + f(1) + 1

f(n) = f(n-1) + f(n-2) +...+ f(2) + f(1) + 1

说明:

3.1. 这里的f(n) 代表的是n个台阶有一次1,2,…n阶的跳法数。

3.2. n = 1时，只有1种跳法，f(1) = 1

3.3. n = 2时，会有两个跳得方式，一次1阶或者2阶，这回归到了问题（1），f(2) = f(2-1) + f(2-2)

3.4. n = 3时，会有三种跳得方式，1阶、2阶、3阶,那么就是第一次跳出1阶后面剩下：f(3-1);第一次跳出2阶，剩下f(3-2)；第一次3阶，那么剩下f(3-3)因此结论是:

f(3) = f(3-1)+f(3-2)+f(3-3)

3.5. n = n时，会有n中跳的方式，1阶、2阶…n阶，得出结论：

f(n) = f(n-1)+f(n-2)+...+f(n-(n-1)) + f(n-n) => f(0) + f(1) + f(2) + f(3) + ... + f(n-1)

3.6. 由以上已经是一种结论，但是为了简单，我们可以继续简化：

f(n-1) = f(0) + f(1)+f(2)+f(3) + ... + f((n-1)-1) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2)
f(n) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2) + f(n-1) = f(n-1) + f(n-1)

3.7. 得出最终结论,在n阶台阶，一次有1、2、…n阶的跳的方式时，总得跳法为：

            | 1       ,(n=0 ) 
            |
f(n) =      | 1       ,(n=1 )
            |
            | 2*f(n-1),(n>=2)

代码实现

# 递归 - 法1
def jump(n):
    while n<=2:
        return n
    return jump(n-1)*2
print(jump(5))

# 递归 - 法2
def jump(n):
    while n<=2:
        return n
    return 2**(n-1)
print(jump(5))

#2.4 兔子繁殖

GitHub
问题描述

有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

思路

f(N) : 第N个月兔子的总数 f(Nbefore) : 第N个月之前出生的兔子 f(Nnew) : 第N个月出生的兔子 f(N) = f(Nbefore) + f(Nnew) = f(N-1) + f(Nnew)

到了第(N+1)个月时:第N个月出生的兔子还不能繁殖,第N个月之前出生的兔子全部都可以繁殖

f(N+1) = f(Nnew) + f(Nbefore)_2 = f(Nnew) + 2_f(N-1)

由:
f(N) =  f(N-1) + f(Nnew)
f(N+1) = f(Nnew) + 2*f(N-1)

得:
f(N+1) = f(N) + f(N-1)

代码实现

def fib(max_val):
    a, b, n = 1, 2, max_val
    while n:
        a, b = b, a+b
        n -= 1
    return b
n = 5 # 第N月
ret = n if n <= 2 else fib(n)
print(ret)

#2.5 列表去重

没有时间空间复杂度限制

def func(tar):
    tar_copy = []
    for foo in tar:
        if foo not in tar_copy:
            tar_copy.append(foo)
    return tar_copy
ret = func([1,2,2,2,2,3,4,5,6,7,8,9,8,1,2,3,4])
print(ret)

时间复杂度

O(n)

空间复杂度

O(n)

有序列表 + 时间复杂度O(n) + 空间复杂度O(1)

意味着只能有一个for循环+只能在原表操作

def func(tar):
    for i,num in enumerate(tar):
        try: # tar[i+1] 到最后一个会抛异常
            while num == tar[i+1]:
                tar.pop(i+1)
        except:
            break
    return tar
ret = func([1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 7, 8, 8, 9, 9, 9])
print(ret)