python-24-初识递归函数与算法

前言

初识递归函数与算法，递归其实就是在函数内部调用自己，算法就是一个计算的方法，我们简单了解一下递归实现的二分查找算法。

一、初识递归

1、简单递归函数

1.如果是这样子，那么就停不下来，但python为了杜绝无限调用，就做了限制。
2.限制默认为：998，如下面函数所示。
3.递归不合适解决次数很多，因为占内存，但递归能让代码更简单

RecursionError:递归错误，是超出了递归的最大深度。

# 1、简单递归函数：
n = 0
def func():
    global n
    n += 1
    print(n)
    func()
func()

2、修改递归最大的深度:sys.setrecursionlimit

最大深度与自己的电脑配置有关，性能好点的电脑应该是可以多跑点的。不要随意改动，python从内存角度出发做了限制，肯定是有它的好处！

# 2、修改递归最大的深度:sys.setrecursionlimit
import sys
sys.setrecursionlimit(100000)
n = 0
def func():
    global n
    n += 1
    print(n)
    func()
func()

3、递归实例：

看例子我们知道只要知道D是多少头猪，我们都能算出ABC家的数量了

# 3、递归实例
'''
A:我家比B多三头，你们猜我家有几头猪？  n=1   head(1)=head(2)+2 =head(n+1)+2
B:我家比C家多三头。                  n=2   head(2)=head(3)+2 =head(n+1)+2
C:我家比D家多三头。                  n=3   head(3)=head(4)+2 =head(n+1)+2
D:我家有15头猪                      n=4   head(4)=15
'''

def head(n):
    if n == 4:
        return 15
    elif n>0 and n<4:
        return head(n+1)+3

print('n=1:', head(1))
print('n=2:', head(2))
print('n=3:', head(3))
print('n=4:', head(4))

4、看懂递归，如下图所示：

# 4、看懂递归
def head(1):                 # 我自己的函数传参是：1，所以先将 n=1 传入head函数内。
    if 1 == 4:
        return 15
    elif 1>0 and 1<4:
        return head(1+1)+3   # head(1+1)，到这一步调用了 head(2)

def head(2):                 # head(2) ，所以将2传入下面的函数n
    if 2 == 4:
        return 15
    elif 2>0 and 2<4:
        return head(2+1)+3   # head(2+1)，到这一步调用了 head(3)

def head(3):                 # head(3) ，所以将3传入下面的函数n
    if 3 == 4:
        return 15
    elif 3>0 and 3<4:
        return head(3+1)+3   # head(4) ，所以将4传入下面的函数n

def head(4):
    if 4 == 4:               # 4 == 4，所以知道了，head(4)=15，将15返回给上一次调用的head(3)中
        return 15
    elif 4>0 and 4<4:
        return head(4+1)+3

print('n=1:', head(1))

二、初识算法

1.二分查找算法实例：

特点：必须处理有序的列表，每次处理中间值来判断大了还是小了，对应放向再次处理中间值...

# 查找我输入的数字，每次该向哪边找？
def find(lst, aim):
    mid = len(lst) // 2
    if aim < lst[mid]:
        print(aim,'小于了中间值%s所以向左继续找' % lst[mid])
        new = lst[:mid]
        find(new, aim)
    elif aim > lst[mid]:
        print(aim,'大于了中间值%s所以向右继续找' % lst[mid])
        new = lst[mid+1:]
        find(new, aim)
    else:print('最终找到：', aim)

lst = [1, 2, 4, 6, 12, 23, 33, 56, 66, 67, 89, 92, 105]
find(lst, 67)

2.基于上面实例，我需要知道索引下标该怎么办呢？

列表本身的元素个数是不能改变了，那么我们可以通过变量来计算出。

# 我想知道这个索引的下标是多少
def find(lst, aim, start=0, end=None):
    end = len(lst) if end is None else end
    mid_index = (end-start) // 2 + start
    if start < end:
        if aim < lst[mid_index]:
            return find(lst, aim, start=start, end=mid_index-1)
        elif aim > lst[mid_index]:
            return find(lst, aim, start=mid_index+1, end=end)
        else:return'最终找到：%s，下标为：%s' % (aim, mid_index)
    else:return '找不到该值：%s' % aim

lst = [1, 2, 4, 6, 12, 23, 33, 56, 66, 67, 89, 92, 105]
ret = find(lst, 33)
print(ret)

欢迎来大家QQ交流群一起学习：482713805

python-24-初识递归函数与算法

前言

一、初识递归

二、初识算法

猜你喜欢