python 递归和二分法查找

 1. 递归:

    自己调自己难点:不好想,需要找规律不好读

 2. 二分法

    头,结尾,取中间, 不停的改变左和右,间接改变中间,查询效率非常高



1. 递归(方法一:)

# 递归的用处: 遍历树形结构(拿一个数据进行遍历,得到两个结果在进行遍历,得到四个结果...,这是树形结构)
import os
filePath = "d:/untitled"

it = os.listdir(filePath)       # 查看文件夹中的文件,
# print(it)   # 以列表的形式打印

print("__iter__" in dir(it))    # 判断是否可迭代,里面的列表可以迭代, 返回True
for i in it:
    print(i)      # 直接打印,不是以列表的形式

import os
filePath = "d:/untitled"

def read(filePath,n):
    it = os.listdir(filePath)       # listdir 查看(打开)文件夹中的文件
    # print("__iter__" in dir(it))  # 可迭代对象
    # print("__next__" in dir(it))  不是迭代器
    for i in it:
        if os.path.isdir(os.path.join(filePath,i)):        #  isdir 判断是否是文件夹 os.path.join 固定写法(拼接)
            print("\t" * n, i)      # 打印文件夹,
            # print(i)
            # 再次调用本函数
            # read(i)
            read(os.path.join(filePath,i),n+1)  # 拿到路径(用原先的路径+进去的一层文件加,组成一个新的路径)

        else:       # 普通文件, 不是文件夹了
            print("\t"*n,i)        # 递归的出口,递归了一次,n是判断递归的次数

read(filePath,0)
# 解释:
# 就是把一个文件夹打开,判断是否是文件,如果出现了另一个文件夹,然后进行拼接,出现新的路径
# 如果再打开还是文件夹的话,继续拼接,直到出现文件为止,打印出内容.

普通的递归方法


 

 2. 递归(方法二:)

import os
filePath = "d:/untitled"
def read(filePath, n):      # n 递归深度
    it = os.listdir(filePath)       # listdir 查看(打开)文件夹中的文件
        # print("__iter__" in dir(it))  # 可迭代对象
    for i in it:    # 打开一层
        # 拿到路径
            fp = os.path.join(filePath, i)  # 拼接
            if os.path.isdir(fp):       # 判断是否是文件夹
                print("\t"*n, i)
                read(fp,n+1)        # 又是文件夹了,继续读取内部的内容,递归入口
            else:
                print("\t"*n,i)        # 递归出口

read(filePath, 1)

遍历树形结构

 3. 二分查找法

# 方法一: (普通方法)
lst= [11,22,33,44,55,66,77,88,99]       # // 地板除
n = 66
left = 0
right = len(lst) - 1        # 长度 - 1 = 索引
count = 1
while left <= right:
    middle = (left + right) // 2
    if n > lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        print(count)
        print("存在")
        print(middle)               # middle 是中间索引
        break
    count = count + 1
else:
    print("不存在")

# 方法二: (递归 二分法)
lst= [11,22,33,44,55,66,77,88,99]

def binary_search(left, right, n):
    middle = (left + right)//2
    if left > right:
        print("没有")
        return -1   # 没有会返回-1
    if n > lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        return middle   # 有的话,返回输入值的索引
    return binary_search(left,right,n)  # n表示你输入的值,判断的值的索引
print(binary_search(0,len(lst)-1,65))



原文地址:https://www.cnblogs.com/Pengdachui-1/p/11619444.html

时间: 2024-10-08 10:08:52

python 递归和二分法查找的相关文章

递归实现二分法查找----python

下面是一个最简单的二分法递归实现快速查找的例子,之所以把这么简单的例子写上来是觉得这个小例子可以很好地说明递归的用法和使用技巧. def find(n,array):     left = 0     right = len(array)-1     while left <= right:         mid = (left+right)//2         if n == array[mid]:             print(n)             return True

python递归函数及二分法查找

函数的递归: 在一个函数的内部调用自己 死循环: 可以无限循环,不会停止 while True: print('我不是递归') 递归: 不是死循环,有最大循环深度 def story(): print('我是递归') story() story() 超过了递归的最大深度报错 RecursionError: maximum recursion depth exceeded while calling a Python object 官网上 源码中设置的递归深度: 1000自己实际测试递归深度: 9

python 递归和二分法

一 内置函数 1. revserd 翻转,返回的是迭代器 # 将 s 倒置 s = '不是上海自来水来自海上' # 方法一 print(s[::-1]) # 方法二 s1 = reversed(s) i = '' for el in s1: i +=el print(i) 2.slice 切片 lis = ['nishi','woshi','shuia','benjim'] s = slice(1,3) print(lis[s]) 3.formate # 格式化输出 s = "我叫{name},

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. 递归 (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写个二分法查找

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

14 内置函数 递归 二分法查找

今日主要内容 1. 昨日补充 repr() 显示出字符串的官方表示形式 chr() ord() 2. 递归 自己调用自己 递归的入口(参数) 和 出口(return) 树形结构的遍历 3. 二分法 掐头结尾取中间 查找效率非常的高 1.递归2.二分法查找 原文地址:https://www.cnblogs.com/work14/p/10209198.html

关于递归与二分查找技术

简单的说,递归就是函数自己调用自己.在数据结构里面会经常使用递归,因为递归代码比较简洁优雅,易懂. 编写递归程序时主要注意三点 (1)递归总有一个最简单的情况,方法的第一条语句总是包含return的条件语句 (2)递归调用总是去尝试解决一个规模更小的子问题,这样递归才能收敛到最简单的情况.在下面代码中,第四个参数和第三个参数的差值一直在缩小 (3)递归调用的父问题和尝试解决的子问题之间不应该有交集.在如下代码中,两个子问题,各自操作的数组部分是不同的 下面是二分法查找的递归实现和非递归实现: 特

二分法查找和快速排序

二分法是分治算法的一种特殊形式,利用分治策略求解时,所需时间取决于分解后子问题的个数.子问题的规模大小等因素,而二分法,由于其划分的简单和均匀的特点,是查找数据时经常采用的一种有效的方法. 快速排序的实质也是二分法,下面就写一个快速排序+二分法查找的栗子??: 1 #include<stdio.h> 2 3 4 //快速排序 5 void QuickSort(int * a,int left,int right) 6 { 7 if(left>right) 8 { 9 return; 10