python递归遍历树
1. 关于python中一个递归二叉树遍历的问题
你在出错的地方前面加个print，把这两个值都print出来不就知道错在哪个了？
2. python怎么用递归遍历多层目录树
#coding=utf-8
search_id = '69d0'
search_list = [{'id':'0337', 'name':'de', 'parent_id':'None'},
{'id':'2ddf', 'name':'se', 'parent_id':'None'},
{'id':'3010', 'name':'12', 'parent_id':'69d0'},
{'id':'3119', 'name':'121', 'parent_id':'3010'},
{'id':'3229', 'name':'1211', 'parent_id':'3119'},
{'id':'3d37', 'name':'14', 'parent_id':'69d0'},
{'id':'58c8', 'name':'11', 'parent_id':'69d0'},
{'id':'63b9', 'name':'a','parent_id':'None'},
{'id':'954c', 'name':'n', 'parent_id':'63b9'},
{'id':'69d0', 'name':'1', 'parent_id':'954c'},
{'id':'d2f9', 'name':'13', 'parent_id':'69d0'},
{'id':'defb', 'name':'test', 'parent_id':'None'}]
search_ids = []
#例如如果search_id = '69d0' search_ids=[3010,3d37,58c8,d2f9,3119,3229]
def search_pid(pid,id_list,id_results):
for id in id_list:
if id['id'] not in id_results:
if id['parent_id'] in pid:
id_results.append(id['id'])
pid.append(id['id'])
search_pid(pid,id_list,id_results)
search_pid([search_id],search_list,search_ids)
print search_ids
3. Python3：怎么通过递归函数
函数的递归调用
递归问题是一个说简单也简单，说难也有点难理解的问题.我想非常有必要对其做一个总结.
首先理解一下递归的定义，递归就是直接或间接的调用自身.而至于什么时候要用到递归，递归和非递归又有那些区别？又是一个不太容易掌握的问题，更难的是对于递归调用的理解.下面我们就从程序+图形的角度对递归做一个全面的阐述.
我们从常见到的递归问题开始:
1 阶层函数
#include <iostream>
using namespace std;
int factorial(int n)
{
if (n == 0)
{
return 1;
}
else
{
int result = factorial(n-1);
return n * result;
}
}
int main()
{
int x = factorial(3);
cout << x << endl;
return 0;
}
这是一个递归求阶层函数的实现。很多朋友只是知道该这么实现的，也清楚它是通过不断的递归调用求出的结果.但他们有些不清楚中间发生了些什么.下面我们用图对此做一个清楚的流程:
根据上面这个图，大家可以很清楚的看出来这个函数的执行流程。我们的阶层函数factorial被调用了4次.并且我们可以看出在调用后面的调用中，前面的调用并不退出。他们同时存在内存中。可见这是一件很浪费资源的事情。我们该次的参数是3.如果我们传递10000呢。那结果就可想而知了.肯定是溢出了.就用int型来接收结果别说10000，100就会产生溢出.即使不溢出我想那肯定也是见很浪费资源的事情.我们可以做一个粗略的估计:每次函数调用就单变量所需的内存为:两个int型变量.n和result.在32位机器上占8B.那么10000就需要10001次函数调用.共需10001*8/1024 = 78KB.这只是变量所需的内存空间.其它的函数调用时函数入口地址等仍也需要占用内存空间。可见递归调用产生了一个不小的开销.
2 斐波那契数列
int Fib(int n)
{
if (n <= 1)
{
return n;
}
else
{
return Fib(n-1) + Fib(n-2);
}
}
这个函数递归与上面的那个有些不同.每次调用函数都会引起另外两次的调用.最后将结果逐级返回.
我们可以看出这个递归函数同样在调用后买的函数时，前面的不退出而是在等待后面的结果，最后求出总结果。这就是递归.
3
#include <iostream>
using namespace std;
void recursiveFunction1(int num)
{
if (num < 5)
{
cout << num << endl;
recursiveFunction1(num+1);
}
}
void recursiveFunction2(int num)
{
if (num < 5)
{
recursiveFunction2(num+1);
cout << num << endl;
}
}
int main()
{
recursiveFunction1(0);
recursiveFunction2(0);
return 0;
}
运行结果:
0
1
2
3
4
4
3
2
1
0
该程序中有两个递归函数。传递同样的参数，但他们的输出结果刚好相反。理解这两个函数的调用过程可以很好的帮助我们理解递归:
我想能够把上面三个函数的递归调用过程理解了，你已经把递归调用理解的差不多了.并且从上面的递归调用中我们可以总结出递归的一个规律：他是逐级的调用，而在函数结束的时候是从最后面往前反序的结束.这种方式是很占用资源，也很费时的。但是有的时候使用递归写出来的程序很容易理解，很易读.
为什么使用递归:
1 有时候使用递归写出来的程序很容易理解，很易读.
2 有些问题只有递归能够解决.非递归的方法无法实现.如:汉诺塔.
递归的条件:
并不是说所有的问题都可以使用递归解决，他必须的满足一定的条件。即有一个出口点.也就是说当满足一定条件时，程序可以结束，从而完成递归调用，否则就陷入了无限的递归调用之中了.并且这个条件还要是可达到的.
递归有哪些优点:
易读，容易理解，代码一般比较短.
递归有哪些缺点:
占用内存资源多，费时，效率低下.
因此在我们写程序的时候不要轻易的使用递归，虽然他有他的优点，但是我们要在易读性和空间，效率上多做权衡.一般情况下我们还是使用非递归的方法解决问题.若一个算法非递归解法非常难于理解。我们使用递归也未尝不可.如:二叉树的遍历算法.非递归的算法很难与理解.而相比递归算法就容易理解很多.
对于递归调用的问题，我们在前一段时间写图形学程序时，其中有一个四连同填充算法就是使用递归的方法。结果当要填充的图形稍微大一些时，程序就自动关闭了.这不是一个人的问题，所有人写出来的都是这个问题.当时我们给与的解释就是堆栈溢出。就多次递归调用占用太多的内存资源致使堆栈溢出，程序没有内存资源执行下去，从而被操作系统强制关闭了.这是一个真真切切的例子。所以我们在使用递归的时候需要权衡再三.
4. 想学习Python要看什么书呢(我是初学者)
《深度学习入门》（[ 日］ 斋藤康毅）电子书网盘下载免费在线阅读
资源链接：
链接: https://pan..com/s/1ddnvGv-r9PxjwMLpN0ZQIQ
书名：深度学习入门
作者：[ 日］ 斋藤康毅
译者：陆宇杰
豆瓣评分：9.4
出版社：人民邮电出版社
出版年份：2018-7
页数：285
内容简介：本书是深度学习真正意义上的入门书，深入浅出地剖析了深度学习的原理和相关技术。书中使用Python3，尽量不依赖外部库或工具，从基本的数学知识出发，带领读者从零创建一个经典的深度学习网络，使读者在此过程中逐步理解深度学习。书中不仅介绍了深度学习和神经网络的概念、特征等基础知识，对误差反向传播法、卷积神经网络等也有深入讲解，此外还介绍了深度学习相关的实用技巧，自动驾驶、图像生成、强化学习等方面的应用，以及为什么加深层可以提高识别精度等“为什么”的问题。
作者简介：
斋藤康毅
东京工业大学毕业，并完成东京大学研究生院课程。现从事计算机视觉与机器学习相关的研究和开发工作。是Introcing Python、Python in Practice、The Elements of Computing Systems、Building Machine Learning Systems with Python的日文版译者。
译者简介：
陆宇杰
众安科技NLP算法工程师。主要研究方向为自然语言处理及其应用，对图像识别、机器学习、深度学习等领域有密切关注。Python爱好者。
5. python怎么做二叉查找树
可以的，和C++中类的设计差不多，以下是二叉树的遍历
class BTree:
def __init__(self,value):
self.left=None
self.data=value
self.right=None
def insertLeft(self,value):
self.left=BTree(value)
return self.left
#return BTree(value)
def insertRight(self,value):
self.right=BTree(value)
return self.right
def show(self):
print self.data
def preOrder(node):
node.show()
if node.left:
preOrder(node.left)
if node.right:
preOrder(node.right)
def inOrder(node):
if node:
if node.left:
inOrder(node.left)
node.show()
if node.right:
inOrder(node.right)
if __name__=='__main__':
Root=BTree('root')
A=Root.insertLeft('A')
C=A.insertLeft('C')
D=A.insertRight('D')
F=D.insertLeft('F')
G=D.insertRight('G')
B=Root.insertRight('B')
E=B.insertRight('E')
preOrder(Root)
print 'This is binary tree in-traversal'
inOrder(Root)
6. 求一个python的三叉树算法
这是网络上的一个版本，我自己做了一点修改，这是一个n叉树，希望对你有所帮助
#!/usr/bin/python
#-*-coding:utf-8-*-
'''
Createdon2014-3-26
@author:qcq
'''
#==============================================================================
#tree.py:
#==============================================================================
#--
#$Revision:1.7$
#$Date:2000/03/2922:36:12$
#modifiedbyqcqin2014/3/27
#modifiedbyqcqin2014/4/23增加了遍历树的非递归版本的广度优先和深度优先
#--
#================================================================
#Contents
#----------------------------------------------------------------
#classTree:Genericn-arytreenodeobject
#classNodeId:Representsthepathtoanodeinann-arytree
#----------------------------------------------------------------
#importstring
classTree:
"""Genericn-arytreenodeobject
Childrenareadditive;noprovisionfordeletingthem.
:0forthefirst
childadded,1forthesecond,andsoon.
modifiedbyqcqin2014/3/27.
Exports:
Tree(parent,value=None)Constructor
.parentIfthisistherootnode,None,otherwise
theparent'sTreeobject.
.childListListofchildren,zeroormoreTreeobjects.
.valueValuepassedtoconstructor;canbeanytype.
.birthOrderIfthisistherootnode,0,otherwisethe
indexofthischildintheparent's.childList
.nChildren()Returnsthenumberofself'schildren.
.nthChild(n)Returnsthenthchild;raisesIndexErrorif
nisnotavalidchildnumber.
.fullPath():.
.nodeId():ReturnspathtoselfasaNodeId.
"""
#---Tree.__init__---
def__init__(self,parent,value=None):
"""ConstructorforaTreeobject.
[if(parentisNoneoraTreeobject)->
if(parentisNone)->
,nochildren,
andvalue(value)
else->
ofparent(parent)andnochildren,andvalue(value)
]
"""
#--1--
self.parent=parent
self.value=value
self.childList=[]
#--2--
#-[if(parentisNone)->
#self.birthOrder:=0
#else->
#parent:=
#self.birthOrder:=sizeofparent's.childList
#-]
ifparentisNone:
self.birthOrder=0
else:
self.birthOrder=len(parent.childList)
parent.childList.append(self)
#---Tree.nChildren---
defnChildren(self):
"""[
]
"""
returnlen(self.childList)
#---Tree.nthChild---
defnthChild(self,n):
"""[if(nisaninteger)->
if(0<=n<(numberofself'schildren)->
returnself's(n)thchild,countingfrom0
else->
raiseIndexError
]
"""
returnself.childList[n]
#---Tree.fullPath---
deffullPath(self):
""".
[returnasequence[c0,c1,...,ci]suchthatselfis
root.nthChild(c0).nthChild(c1).....nthChild(ci),or
anemptylistifselfistheroot]
"""
#--1--
result=[]
parent=self.parent
kid=self
#--2--
#[result+:=childnumbersfromparenttoroot,in
#reverseorder]
whileparent:
result.insert(0,kid.birthOrder)
parent,kid=parent.parent,parent
#--3--
returnresult
#---Tree.nodeId---
defnodeId(self):
""".
"""
#--1--
#[fullPath:=sequence[c0,c1,...,ci]suchthatselfis
#root.nthChild(c0).nthChild(c1).....nthChild(ci),or
#anemptylistifselfistheroot]
fullPath=self.fullPath()
#--2--
returnNodeId(fullPath)
defequals(self,node):
'''
'''
returnself.value==node.value
#===========================================================================
#deletethenodefromthetree
#===========================================================================
defdelete(self):
ifself.parentisNone:
return
else:
#temp=self.birthOrder
'''
ifdeletethemiddletreeobject,
.
'''
self.parent.childList.remove(self.parent.childList[self.birthOrder])
fori,jinzip(range(self.birthOrder+1,self.parent.nChildren()),self.parent.childList[self.birthOrder+1:]):
j.birthOrder=j.birthOrder-1
defupdate(self,value):
'''
'''
self.value=value
def__str__(self):
return"The%dchildwithvalue%d"%(self.birthOrder,self.value)#-----classNodeId-----
classNodeId:
""".
Exports:
NodeId(path):
[->
-id]
.path:[aspassedtoconstructor]
.__str__():[returnselfasastring]
.find(root):
[ifrootisaTreeobject->
treerootedat(root)->
returnthe.valueofthatnode
else->
returnNone]
.isOnPath(node):
[ifnodeisaTreeobject->
->
return1
else->
return0]
"""
#---NodeId.__init__---
def__init__(self,path):
"""ConstructorfortheNodeIdobject
"""
self.path=path
#---NodeId.__str__---
def__str__(self):
"""Returnselfindisplayableform
"""
#--1--
#[L:=alistoftheelementsofself.pathconvertedtostrings]
L=map(str,self.path)
#--2--
#["/"]
returnstring.join(L,"/")
#---NodeId.find---
deffind(self,node):
"""
"""
returnself.__reFind(node,0)
#---NodeId.__reFind---
def__reFind(self,node,i):
"""Recursivenodefindingroutine.Startsatself.path[i:].
[if(nodeisaTreeobject)
and(0<=i<=len(self.path))->
ifi==len(self.path)->
returnnode'svalue
elseifself.path[i:]describesapathfromnode
tosometreeobjectT->
returnT
else->
returnNone]
"""
#--1--
ifi>=len(self.path):
returnnode.value#We'rethere!
else:
childNo=self.path[i]
#--2--
#[->
#child:=thatchildnode
#else->
#returnNone]
try:
child=node.nthChild(childNo)
exceptIndexError:
returnNone
#--3--
#[if(i+1)==len(self.path)->
#returnchild
#elseifself.path[i+1:]describesapathfromnodeto
#sometreeobjectT->
#returnT
#else->
#returnNone]
returnself.__reFind(child,i+1)
#---NodeId.isOnPath---
defisOnPath(self,node):
"""Isself'spathtoorthroughthegivennode?
"""
#--1--
#[nodePath:=pathlistfornode]
nodePath=node.fullPath()
#--2--
#[ifnodePathisaprefixof,oridenticaltoself.path->
#return1
#else->
#return0]
iflen(nodePath)>len(self.path):
return0#Nodeisdeeperthanself.path
foriinrange(len(nodePath)):
ifnodePath[i]!=self.path[i]:
return0#Nodeisadifferentroutethanself.path
return1
7. 一个关于Python层级套层级的问题
你这完全就是二叉树的遍历呀。
http://ke..com/view/549587.htm?fr=aladdin
自己网络“二叉树的遍历”
不太明白你说的什么意思，看完二叉树的遍历，你应该就会了
http://blog.csdn.net/sjf0115/article/details/8645991 随便找的，你自己找找看
这个是python 递归遍历的 很简单 只是你说的数据结构不太清楚
http://www.cnblogs.com/yupeng/p/3414451.html
8. python 递归函数使用装饰器
参考一下
第一步：简单实现装饰器
def login(func):
print("in Login")
return func
def tv(name):
print("{name} in TV".format(name = name))
tv = login(tv)
tv('Jack')
# out:
# in Login
# Jack in TV
第二步：同上
效果相同，但是使用的是@login
def login(func):
print("in Login")
return func
@login
def tv(name):
print("{name} in TV".format(name = name))
#tv = login(tv)
tv('Jack')
# out:
# in Login
# Jack in TV
但是出现问题，注销最后的执行语句仍有输出，原因在于@login的调用，即@login相当于执行了tv = login(tv) 所以才有输出。
def login(func):
print("in Login")
return func
@login
def tv(name):
print("{name} in TV".format(name = name))
#tv = login(tv)
#tv('Jack')
# out:
# in Login
如下调整可解决
def login(func):
def inner(arg):
print("in Login")
# return func
func(arg)
return inner
@login
def tv(name):
print("{name} in TV".format(name = name))
#tv = login(tv)
tv('Jack')
# out:
# in Login
# Jack in TV
简单的递归函数
#!/usr/bin/env python
#递归函数
def calc(num):
print("Number:",num)
if num/2 > 1:
calc(num/2)
print("After Number:",num/2)
calc(10)
# Number: 10
# Number: 5.0
# Number: 2.5
# Number: 1.25
# After Number: 1.25
# After Number: 2.5
# After Number: 5.0
递归实现斐波那契数列
# Fibonacci sequence
# F[n]=F[n-1]+F[n-2](n>=2,F[0]=1,F[1]=1)
# 斐波那契数列：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ...
fibList = [1,1]
def getFib(fibList):
print(fibList)
if fibList[-1] + fibList[-2] < 300:
fibList.append(fibList[-1] + fibList[-2])
getFib(fibList)
pass
pass
getFib(fibList)
print("[FINAL]:",fibList)
# [1, 1]
# [1, 1, 2]
# [1, 1, 2, 3]
# [1, 1, 2, 3, 5]
# [1, 1, 2, 3, 5, 8]
# [1, 1, 2, 3, 5, 8, 13]
# [1, 1, 2, 3, 5, 8, 13, 21]
# [1, 1, 2, 3, 5, 8, 13, 21, 34]
# [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
# [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
# [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]
# [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
# [FINAL]: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]