python--递归、二分查找算法

                                递归

初识递归

递归的定义——在一个函数里再调用这个函数本身

现在我们已经大概知道刚刚讲的story函数做了什么,就是在一个函数里再调用这个函数本身,这种魔性的使用函数的方式就叫做递归

刚刚我们就已经写了一个最简单的递归函数。

递归的最大深度——997

正如你们刚刚看到的,递归函数如果不受到外力的阻止会一直执行下去。但是我们之前已经说过关于函数调用的问题,每一次函数调用都会产生一个属于它自己的名称空间,如果一直调用下去,就会造成名称空间占用太多内存的问题,于是python为了杜绝此类现象,强制的将递归层数控制在了997(只要997!你买不了吃亏,买不了上当...).

递归函数与三级菜单

menu = { ‘北京‘: { ‘海淀‘: { ‘五道口‘: { ‘soho‘: {}, ‘网易‘: {}, ‘google‘: {} }, ‘中关村‘: { ‘爱奇艺‘: {}, ‘汽车之家‘: {}, ‘youku‘: {}, }, ‘上地‘: { ‘百度‘: {}, }, }, ‘昌平‘: { ‘沙河‘: { ‘老男孩‘: {}, ‘北航‘: {}, }, ‘天通苑‘: {}, ‘回龙观‘: {}, }, ‘朝阳‘: {}, ‘东城‘: {}, }, ‘上海‘: { ‘闵行‘: { "人民广场": { ‘炸鸡店‘: {} } }, ‘闸北‘: { ‘火车战‘: { ‘携程‘: {} } }, ‘浦东‘: {}, }, ‘山东‘: {}, }

1 def threeLM(dic):

2 while True:

3 for k in dic:print(k)

4 key = input(‘input>>‘).strip()

5 if key == ‘b‘ or key == ‘q‘:return key

6 elif key in dic.keys() and dic[key]:

7 ret = threeLM(dic[key])

8 if ret == ‘q‘: return ‘q‘

9 elif (not dic.get(key)) or (not dic[key]) :

10 continue

11

12 threeLM(menu)

二分法

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]

你观察这个列表,这是不是一个从小到大排序的有序列表呀?

如果这样,假如我要找的数比列表中间的数还大,是不是我直接在列表的后半边找就行了?

这就是二分查找算法

贴上两段代码:

一:简单二分法

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]

def func(l,aim):

mid = (len(l)-1)//2

if l:

  if aim > l[mid]:

    func(l[mid+1:],aim)

  elif aim < l[mid]:

    func(l[:mid],aim)

  elif aim == l[mid]:

    print("bingo",mid)

  else: print(‘找不到‘)

func(l,66)

func(l,6)

二:

  升级版二分法

def func(l, aim,start = 0,end = len(l)-1 ):

  mid = (start+end)//2

  if not l[start:end+1]:

    return

  elif aim > l[mid]:

    return func(l,aim,mid+1,end)

  elif aim < l[mid]:

    return func(l,aim,start,mid-1)

  elif aim == l[mid]:

    print("bingo")

  return mid

index = func(l,68)

print(index)

      

#递归解决的问题#就是通过参数,来控制每一次缩小计算的规模#适合的场景:数据的规模在减小 解决问题的思路在改变#总结:结束递归的标志:return#用处:未来遇到很多递归的地方,算法(排序算法,金融类)  9#递归函数:在一个函数里调用自己#最大递归层数做了一个限制:997#最大层数限制是python默认的。可以做修改#但是不建议修改#import sys #所以和python相关的设置和放到# def a():#     print("ff")#     a()# a()## import sys# sys.setrecursionlimit(10000000)# n =1# def a():#      global n#      n += 1# #     print("ff")#      print(n)#      a()# a()

# def age(n):#     if n == 1:#         return 40#     else:#         ret = age(n-1)#         return ret + 2# print(age(5))# def age(5):#     if 5 == 1:#         return 40#     else:#         ret = 46#         return ret + 2## def age(4):#     if 5 == 1:#         return 40#     else:#         ret = 44#         return ret + 2## def age(3):#     if 5 == 1:#         return 40#     else:#         ret = 42#         return 44## def age(2):#     if 5 == 1:#         return 40#     else:#         ret = 40#         return 42## def age(1):#     if 5 == 1:#         return 40

#age(1)  == 40## l = [1,2,3,4,5,6,7,8,9,10,11,12,23,45,67,89,100]# def find(l,aim):#     mid = len(l)//2#     if l[mid] > aim:#         ll=l[:mid]#         return find(ll,aim)#     elif l[mid] < aim:#         ll= l[mid+1:]#         return find(ll,aim)#     else:#         return l.index(aim)# print(find(l,11))## def a(num):#     if num %2.2 == 0:#         num = num // 2#         return a(num)#     else:#         return num# print(a(8.8))menu = {    ‘北京‘: {        ‘海淀‘: {            ‘五道口‘: {                ‘soho‘: {},                ‘网易‘: {},                ‘google‘: {}            },            ‘中关村‘: {                ‘爱奇艺‘: {},                ‘汽车之家‘: {},                ‘youku‘: {},            },            ‘上地‘: {                ‘百度‘: {},            },        },        ‘昌平‘: {            ‘沙河‘: {                ‘老男孩‘: {},                ‘北航‘: {},            },            ‘天通苑‘: {},            ‘回龙观‘: {},        },        ‘朝阳‘: {},        ‘东城‘: {},    },    ‘上海‘: {        ‘闵行‘: {            "人民广场": {                ‘炸鸡店‘: {}            }        },        ‘闸北‘: {            ‘火车战‘: {                ‘携程‘: {}            }        },        ‘浦东‘: {},    },    ‘山东‘: {},}# def ak(men):#     while True:#         for key in men:#             print(key)#         k = input("input>>>")#         return ak(men[k])# print(ak(menu))# def ak(men):# #    print("大区信息")#     while True:#         for key in men:#             print(key)#         k = input("input(quit或者exit退出)>>>")#         if k =="quit" or k == "exit":#             return k#         else:#             return ak(men[k])# print(ak(menu))#
时间: 2024-09-28 20:59:07

python--递归、二分查找算法的相关文章

Python 实现二分查找算法

最近在学习python,由于在面试中,二分查找算法面试率极高,所以使用python做了一个实现. def search1(sequence, number): lower = 0 upper = len(sequence) - 1 while lower <= upper: mid = (lower + upper) // 2 if number > sequence[mid]: lower = mid + 1 elif number < sequence[mid]: upper = m

二分查找算法(递归与非递归两种方式)

首先说说二分查找法. 二分查找法是对一组有序的数字中进行查找,传递相应的数据,进行比较查找到与原数据相同的数据,查找到了返回1,失败返回对应的数组下标. 采用非递归方式完成二分查找法.java代码如下所示. /* * 非递归二分查找算法 * 参数:整型数组,需要比较的数. */ public static int binarySearch(Integer[]srcArray,int des){ //第一个位置. int low=0; //最高位置.数组长度-1,因为下标是从0开始的. int h

基础算法介绍 —— 二分查找算法

不知不觉在目前的公司待满3年了,打算回家找份工作.面试中被问到关于算法的题目:有哪些常见的查找算法?下来就把我所掌握的查找算法分享给大家,本文主要介绍二分查找算法. 算法定义(摘自百度):二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好:其缺点是要求待查表为有序表,且插入删除困难.因此,折半查找方法适用于不经常变动而查找频繁的有序列表.首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功:否则利用中间位置记录将表分成前.后两个子表,如果

Python——递归、二分查找算法

递归函数 1. 递归 (1)什么是递归:在函数中调用自身函数(2)最大递归深度:默认997/998--是Python从内存角度出发做的限制 n = 0 def story(): global n n+= 1 print(n) story() #997/998 story() (3)修改最大深度:最好不要改--递归次数太多,则不适合用递归解决问题 import sys sys.setrecursionlimit(2000) #1997/1998 2. 递归的优点 会让代码变简单 3. 递归的缺点

python函数:递归函数及二分查找算法

本文和大家分享的主要是python的递归函数及二分查找算法相关内容,一起来看看吧,希望对大家学习python有所帮助. 一.递归的定义 def story(): s = """ 从前有个山,山里有座庙,庙里老和尚讲故事, 讲的什么呢? """ print(s) story() story() 老和尚讲故事 递归的定义 -- 在一个函数里再调用这个函数本身.这种魔性的使用函数的方式就叫做 递归 . 递归的最大深度:997 1.python递归最大层

算法前戏 递归 二分查找 列表查找

一.递归 概念: 函数直接或者间接的调用自身算法的过程,则该函数称为递归函数.在计算机编写程序中,递归算法对解决一大类问题是十分有效的. 特点: ①递归就是在过程或者函数里调用自身. ②在使用递归策略时,必须有一个明显的结束条件,称为递归出口.问题规模相比上次递归有所减少, ③递归算法解题通常显得很简洁,但递归算法解题的效率较低.所以一般不倡导使用递归算法设计程序. ④在递归调用的过程当中系统的每一层的返回点.局部变量等开辟了栈来存储.递归函数次数过多容易造成栈溢出等. 所以一般不倡导用递归算法

二分查找算法的递归实现

还有一个典型的递归例子是对已排序数组的二分查找算法.博e百娱乐城 现在有一个已经排序好的数组,要在这个数组中查找一个元素,以确定它是否在这个数组中,很一般的想法是顺序检查每个元素,看它是否与待查找元素相同.这个方法很容易想到,但它的效率不能让人满意,它的复杂度是O(n)的.现在我们来看看递归在这里能不能更有效. 还是考虑上面的两个条件: 第一:这个问题是否可以分解为形式相同但规模更小的问题? 第二:如果存在这样一种分解,那么这种分解是否存在一种简单情境? 考虑条件一:我们可以这样想,如果想把问题

二分查找算法的Python实现

问题 二分查找 list.index()无法应对大规模数据的查询,需要用其它方法解决,这里谈的就是二分查找 思路说明 在查找方面,python中有list.index()的方法.例如: >>> a=[2,4,1,9,3] #list可以是无序,也可以是有序 >>> a.index(4) #找到后返回该值在list中的位置 1 >>> a.index(5) #如果没有该值,则报错 Traceback (most recent call last): Fi

二分查找算法(递归,循环)

二分查找算法是在有序数组中用到的较为频繁的一种算法,在未接触二分查找算法时,最通用的一种做法是,对数组进行遍历,跟每个元素进行比较,其时间为O(n).但二分查找算法则更优,因为其查找时间为O(lgn),譬如数组{1, 2, 3, 4, 5, 6, 7, 8, 9},查找元素6,用二分查找的算法执行的话,其顺序为:    1.第一步查找中间元素,即5,由于5<6,则6必然在5之后的数组元素中,那么就在{6, 7, 8, 9}中查找,    2.寻找{6, 7, 8, 9}的中位数,为7,7>6,

python之路——二分查找算法

楔子 如果有这样一个列表,让你从这个列表中找到66的位置,你要怎么做? l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88] 你说,so easy! l.index(66)... 我们之所以用index方法可以找到,是因为python帮我们实现了查找方法.如果,index方法不给你用了...你还能找到这个66么? l = [2,3,5,10,15,16,18,22,26,30,32,35,41,