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]