python递归函数及二分法查找

函数的递归: 在一个函数的内部调用自己

死循环: 可以无限循环,不会停止
while True:
    print(‘我不是递归‘)

递归: 不是死循环,有最大循环深度
def story():
    print(‘我是递归‘)
    story()
story()
超过了递归的最大深度报错
RecursionError: maximum recursion depth exceeded while calling a Python object

官网上 源码中设置的递归深度: 1000
自己实际测试递归深度: 998

n = 0
def func():
    global n
    n += 1
    print(n)
    func()
func()
import sys
print(sys.getrecursionlimit())    #查看递归的最大深度

如果你的递归每次都要超过限制 不适合用递归来解决
为什么要有限制? 内存消耗的保护机制
设置递归的最大深度
import sys
sys.setrecursionlimit(1000000)

n = 0
def func():
    global n
    n += 1
    print(n)
    func()
func()

总结
1.递归函数的定义 :一个函数在执行的过程中调用了自己
2.递归在python中的最大深度 : 1000/998
3.递归的最大深度是可以自己修改的,但是不建议你修改

案例(遍历树形结构)
import os
def func(lujing,n):
    lst = os.listdir(lujing)    #打开文件夹,列出该文件夹中的所有文件及目录
    for i in lst:               #循环文件夹中的所有名字,i相当于文件名
        path = os.path.join(lujing,i)   #拼接循环的文件名路径
        # print(path)
        if os.path.isdir(path): #判断拼接后的路径是否是目录
            print(‘\t‘*n,i)       #如果是目录就打印,n等于几就是几个tab键分隔
            func(path,n+1)          #然后再次调用自己,在重复上面的操作,
        else:
            print(‘\t‘*n,i)       #如果不是目录,就打印文件名
func(‘E:/test/‘,0)  #0为分层间隔

二分法查找主要的作用就是查找元素
数据规则: 掐头结尾取中间,必须是有序序列,数据量越大,效率约明显(百万级数据集)

lst = [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]
print(len(lst))
n = int(input(‘<<<<:‘))
start = 0
end = len(lst) -1
count = 0
while start <= end:
    mid = (start + end) // 2
    count+= 1
    if n > lst[mid]:
        start = mid +1
    elif n < lst[mid]:
        end = mid -1
    else:
        print(‘存在‘)
        break
else:
    print(‘不存在‘)
print(‘查找了%s次‘%count)

方法2
lst = [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(n,lst):
    start = 0
    end = len(lst) -1
    # count = 0
    if lst != []:
        mid = (start + end) //2
        if n > lst[mid]:
            func(n,lst[mid+1:])
        elif n < lst[mid]:
            func(n,lst[:mid])
        else:
            print(‘存在‘)
            return
    else:
        print(‘不存在‘)
        return
n = int(input(‘<<<:‘))
func(n,lst)

方法3
lst = [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(n,lst,start,end):
    if start <= end:
        mid = (start + end) //2
        if n > lst[mid]:
            start = mid + 1
            return func(n,lst,start,end)
        elif n < lst[mid]:
            end = mid - 1
            return func(n,lst,start,end)
        else:
            print(‘找到了‘)
            return mid
    else:
        print(‘找不到‘)
        return -1
n = int(input(‘<<:‘))
ret = func(n,lst,0,len(lst)-1)
print(ret)

#最快的查找
lst = [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]
new_lst = []
for i in range(88):
    new_lst.append(0)
for i in lst:
    new_lst[i] = 1
print(new_lst)
i = int(input(‘<<<:‘))
if new_lst[i] == 0:
    print(‘存在‘)
else:
    print(‘不存在‘)

原文地址:https://www.cnblogs.com/wangm-0824/p/10199565.html

时间: 2024-10-13 15:37:43

python递归函数及二分法查找的相关文章

Python写个二分法查找

笔者是一个通信测试攻城狮,之前做过一段时间的持续集成.工作内容只要就是对主线版本进行基本通信功能守护,测试执行都是自动化完成,也是那个时候开始接触到代码. 当时经常遇到的一个问题是:某一天我们发现版本有重大BUG,但是到上一次我们验证PASS中间已经经历过很多版本,我们需要手动从中间找到第一个出现BUG的版本,当然最简单的方法是二分法,取中间版本,根据有没有BUG再缩小范围,继续取中间版本...当时我的想法就是思路很固定,完全可以自动化完成,可惜当时我不会写代码...直到今天看Python递归函

python一个关于二分法查找元素的实现

# coding=utf-8import time def find_ele(alist, ele): if ele < alist[0] or ele > alist[len(alist) - 1]: print("%d not in alist" % ele) return last_index = len(alist) - 1 center_index = last_index // 2 loop_flag = True loop_cout = 0 while loo

python 递归和二分法查找

 1. 递归: 自己调自己难点:不好想,需要找规律不好读  2. 二分法 头,结尾,取中间, 不停的改变左和右,间接改变中间,查询效率非常高 1. 递归(方法一:) # 递归的用处: 遍历树形结构(拿一个数据进行遍历,得到两个结果在进行遍历,得到四个结果...,这是树形结构) import os filePath = "d:/untitled" it = os.listdir(filePath) # 查看文件夹中的文件, # print(it) # 以列表的形式打印 print(&qu

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

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

python 实现二分法查找

二分查找图 二叉树: 代码 #!/usr/bin/python #-*-coding:utf-8-*- #---------------------------------------------------------------------------------------- # to_do : binary find # authors: zuoxingyu # time : 2014-06-07 #--------------------------------------------

python的算法:二分法查找(1)

1.什么是二分法查找: 1.从数组的中间元素开始,如果中间元素正好是要查找的元素,则搜素过程结束: 2.如果某一特定元素大于或者小于中间元素,则在数组大于或小于中间元素的那一半中查找,而且跟开始一样从中间元素开始比较. 3.如果在某一步骤数组为空,则代表找不到. 每次都是i减半查找,其时间消耗为O(logn) 最简单的一个循环算法就是: def binary_search_loop(lst,value): low,high=0,len(value)-1 while low<=high: mid=

Python 二分法查找

使用二分法查找前提必须是有序的数列 def search(list,val): start = 0 end = len(list)-1 #判断该数在不在列表中 if val in list: #循环直到找到该数,return退出函数 while 1: mid = int((start + end)/2) #取整数部分 if list[mid] == val: print('你要查找的数的下标为:%s,'%mid) return mid elif list[mid] > val: end = mi

python之路---14 递归 二分法查找

三十二.递归 1.函数自己调用自己 2.官方说明最大深度1000,但跑不到1000,要看解释器, 实测998 3.使?递归来遍历各种树形结构 三十三.    二分法查找 掐头结尾取中间 ,  必须是有序序列 1. 2. 3. 4. 原文地址:https://www.cnblogs.com/amirky/p/10211564.html

递归函数之二分查找

一.递归 首先引入一个例子 def story(): s = """ 从前有个山,山里有座庙,庙里老和尚讲故事, 讲的什么呢? """ print(s) story() story() 老和尚讲故事 在一个函数里再调用这个函数本身,其最大层数限制是997,最大层数限制是python默认的 结束递归的标志是:return 修改递归最大深度的手段(一般情况下还是别修改比较好) import sys sys.setrecursionlimit(1000