1. 二叉樹的訪問
這個問題我以前回答過了
湊合著看吧
很顯然你還不懂的遍歷一棵二叉樹的原理
當你拿到一棵二叉樹，無論它的形狀如何的千奇百怪
我們都可以將它按照如下的方式劃分
根
/ \
左子樹 右子樹
一棵有很多個節點的二叉樹可以劃分為以上的形式
也可以這么理解，只要是按以上形式組合的都可以稱為是二叉樹
一個僅僅只有根節點的二叉樹也可以劃分成以上的形式，只不過他的左右子樹都為空罷了
所以，我們發現，二叉樹的定義其實是一個遞歸定義的過程
大的二叉樹是由小的二叉樹構建而成的
所以，當我們考慮要遍歷一棵二叉樹時
也是首選遞歸的遍歷
遍歷二叉樹
它的基本思想是先按照上面的形式把整棵二叉樹劃分為3部分
哪么接下來的工作就很簡單了
我們只需要將這3部分都遍歷一遍就可以了（這里用到了分而治之的思想）
而對於這3部分來說
根節點的遍歷無疑是最方便的，直接訪問就ok了
而對於左右子樹呢？
我們不難發現，左右子樹其實分別成為了兩棵完整的樹
他們擁有各自獨立的根節點，左子樹和右子樹
對他們的遍歷，很顯然應該與剛才的遍歷方法一致便可
（如果上面的都理解了，那麼這個題就是小菜一碟了，如果覺得無法理解，可以按照下面的方法自己多分解幾棵樹）
對於這個題目，中序遍歷這可二叉樹
先看根節點
1
/ \
左子樹 右子樹
我們應該先遍歷左子樹
也就是下面這棵樹
2
/ \
4 5
對於這棵樹在進行中序遍歷
我們應先遍歷她的左子樹
他只有一個根節點4，左右子樹都為空
哪么遍歷這個只有一個根節點的二叉樹
先訪問她的左子樹，為空
返回
訪問該樹的根節點4
在訪問右子樹也為空
此時，這棵樹已經被完全的遍歷了
我們需要返回上一層也就是
2
/ \
4 5
這棵樹
此時，她的左子樹已經被訪問完畢
根據中序遍歷的規則
需要訪問此樹的根節點2
此時的訪問順序是4-2
訪問了根節點
在訪問右子樹只有一個根節點的5（具體過程看4的訪問）
5訪問完畢
也就意味著
2
/ \
4 5
這棵樹已經訪問完了
需要返回上一層
也就是1為根的樹
此時這棵樹的左子樹已經訪問完畢
此時訪問的順序是4-2-5應該沒有問題
接下來訪問根節點1
在訪問右子樹
3
/ \
4 7
是不是覺得似曾相識？？？
她的訪問應該跟
2
/ \
4 5
一致
哪么最終遍歷的順序也出來了
4-2-5-1-6-3-7
-----------------------------
花了10多分鍾
希望對你有所幫助
順便自己也復習下
呵呵
匿名 �0�2<span class="tm">6-02 15:05</span>
</p>
<div>
<div class="ra ft"><div class="bt bg1"><img alt="相關內容" class="m" height="16" src="/static/img/ico3.gif" width="16"/>相關內容</div></div>
<p class="ft">
2. 跪求python：求樹從頭到尾的絕對路徑！
# Simple definiton of a tree:
class tree:
def __init__(self, v, l, r):
self.val = v
self.left = l
self.right = r
t = tree("1",tree("A",tree("I",None,None),tree("II",None,None)),
tree("B",tree("I",None,None),tree("II",None,None)))
def traverse(path,t):
# check if t is empty
if (t == None):
return ""
else:
# t is not None
if (t.left != None and t.right != None):
path += t.val +"-"
return traverse(path, t.left) + " " + traverse(path,t.right)
else:
return path + t.val
print(traverse("",t))
10分鍾寫好的事, 不明白為什麼樓主不願意寫.
其實很簡單, 如果你是初學, 有問題可以問我.
3. python 怎麼訪問stanford parser的解析樹
from pythonds.basic.stack import Stack
from pythonds.trees.binaryTree import BinaryTree
def buildParseTree(fpexp):
fplist = fpexp.split()
pStack = Stack()
eTree = BinaryTree('')
pStack.push(eTree)
currentTree = eTree
for i in fplist:
if i == '(':
currentTree.insertLeft('')
pStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif i not in ['+', '-', '*', '/', ')']:
currentTree.setRootVal(int(i))
parent = pStack.pop()
currentTree = parent
elif i in ['+', '-', '*', '/']:
currentTree.setRootVal(i)
currentTree.insertRight('')
pStack.push(currentTree)
currentTree = currentTree.getRightChild()
elif i == ')':
currentTree = pStack.pop()
else:
raise ValueError
return eTree
pt = buildParseTree("( ( 10 + 5 ) * 3 )")
pt.postorder() #defined and explained in the next section
4. 如何在c++和python之間傳遞復雜結構
如果你的c++對象是已有的代碼，可以用cpython包裝成Python對象，這些cpython包裝的對象有一個指針是指向你要包裝的c++對象的，然後提供訪問c++對象的方法。比如你一顆樹可以包裝成Python對象，樹節點也包裝成Python對象，只要是復雜一點的c++對象都可以包裝成Python對象。
如果c++部分的代碼還沒寫，可以用cython直接來寫，這樣自動擴展成Python模塊，這樣的模塊通常是對性能要求很高的才需要專門用c擴展
也可以用Python自帶的ctypes模塊直接定義c++ 對象，這種對象是可以直接導到Python使用的。
5. python elementtree 判斷節點是否有子節點
lxml takes all the pain out of XML.
Stephan Richter
lxml是Python語言里和XML以及HTML工作的功能最豐富和最容易使用的庫。lxml是為libxml2和libxslt庫的一個Python化的綁定。它與眾不同的地方是它兼顧了這些庫的速度和功能完整性，以及純Python API的簡潔性，大部分與熟知的ElementTree API兼容但比之更優越。
安裝lxml：
要求：需要Python2.3或更後的版本
使用easy_install工具，以超級用戶或管理員的角色run下面的命令：
easy_install lxml
在windows下，最好指定版本號：easy_install lxml==2.2.6
使用lxml進行開發
lxml.etree指南
通常使用lxml.etree的方式
>>> from lxml import etree
Element類，一個Element是ElementTree API的主要容器類，大部分的XML tree功能都是通過這個類來訪問的。Elements可以非常容易地通過Element工廠方法來創建。
>>> root = etree.Element("root")
元素的XML tag名字是通過tag屬性來訪問的
>>> print root.tag # root
Elements是在XML樹狀結構中組織的，為創建子元素並將它們加到父元素上，可以使用append()方法。
>>> root.append( etree.Element("child1") )
我們還有更高效的方法：SubElement工廠方法，它使用和Element工廠方法相同的參數，不過額外需要父節點作第一個參數：
>>> child2 = etree.SubElement(root, "child2")
>>> child3 = etree.SubElement(root, "child3")
可以使用tostring()方法來看得到的XML
>>> print etree.tostring(root, pretty_print=True)
<root>
<child1/>
<child2/>
<child3/>
</root>
元素是列表
>>> child = root[0]
>>> print child.tag
child1
>>> print len(root)
3
>>> root.index(root[1]) # lxml.etree only!
1
列印所有子節點：
>>> children = list(root)
>>> for child in root:
... print(child.tag)
child1
child2
child3
可以使用insert()方法插入新的子節點：
>>> root.insert(0, etree.Element("child0"))
刪除子節點：
>>> root[0] = root[-1] # this moves the element!
>>> for child in root:
... print(child.tag)
child3
child1
child2
如果想把一個元素拷貝到不同的地方，需要創建一個獨立的deep 。
>>> from import deep
>>> element = etree.Element("neu")
>>> element.append( deep(root[1]) )
>>> print(element[0].tag)
child1
>>> print([ c.tag for c in root ])
[』child3』, 』child1』, 』child2』]
getparent()返回父節點:
>>> root is root[0].getparent() # lxml.etree only!
True
元素的兄弟或鄰居節點是通過next和previous屬性來訪問的
The siblings (or neighbours) of an element are accessed as next and previous elements:
>>> root[0] is root[1].getprevious() # lxml.etree only!
True
>>> root[1] is root[0].getnext() # lxml.etree only!
True
帶屬性的元素
XML元素支持屬性，可以用Element工廠方法直接創建。
>>> root = etree.Element("root", interesting="totally")
>>> etree.tostring(root)
b』<root interesting="totally"/>』
可以使用set和get方法訪問這些屬性：
>>> print root.get("interesting")
totally
>>> root.set("interesting", "somewhat")
>>> print root.get("interesting")
somewhat
也可以使用attrib性質的字典介面
>>> attributes = root.attrib
>>> print(attributes["interesting"])
somewhat
>>> print(attributes.get("hello"))
None
>>> attributes["hello"] = "Guten Tag"
>>> print(attributes.get("hello"))
Guten Tag
>>> print(root.get("hello"))
Guten Tag
元素可以包含文字：
>>> root = etree.Element("root")
>>> root.text = "TEXT"
>>> print(root.text)
TEXT
>>> etree.tostring(root)
』<root>TEXT</root>』
如果XML用在(X)HTML中，文本也可以在不同的元素中顯示:
<html><body>Hello<br/>World</body></html>
元素有tail屬性，它包含XML 樹中元素直接跟的，直到下個元素的文本。
>>> html = etree.Element("html")
>>> body = etree.SubElement(html, "body")
>>> body.text = "TEXT"
>>> etree.tostring(html)
b』<html><body>TEXT</body></html>』
>>> br = etree.SubElement(body, "br")
>>> etree.tostring(html)
b』<html><body>TEXT<br/></body></html>』
>>> br.tail = "TAIL"
>>> etree.tostring(html)
b』<html><body>TEXT<br/>TAIL</body></html>』
6. python編寫歐式二叉樹的問題
所以我就遇到了一下幾個問題：
1、該怎麼把二叉樹各個節點連起來？
2、怎麼定義內部數據成員？
3、如何實例化左右孩子？
在網上也沒找到比較簡單比較通用的Python二叉樹類實現，所以我花了點時間自己寫一個。
[python] view plain 在CODE上查看代碼片派生到我的代碼片
class Tree:
def __init__(self, val = '#', left = None, right = None):
self.val = val
self.left = left
self.right = right
#前序構建二叉樹
def FrontBuildTree(self):
temp = input('Please Input: ')
node = Tree(temp)
if(temp != '#'):
node.left = self.FrontBuildTree()
node.right = self.FrontBuildTree()
return node#因為沒有引用也沒有指針，所以就把新的節點給返回回去
#前序遍歷二叉樹
def VisitNode(self):
print(self.val)
if(self.val != '#'):
self.left.VisitNode()
self.right.VisitNode()
if __name__ == '__main__':
root = Tree()
root = root.FrontBuildTree()
root.VisitNode()
7. python DOM有什麼用
DOM介紹
（1）什麼是DOM
·DOM：文檔對象模型。DOM 為文檔提供了結構化表示，並定義了如何通過腳本來訪問文檔結構。目的其實就是為了能讓js操作html元素而制定的一個規范。
·DOM就是由節點組成的。
相關推薦：《Python教程》
（2）解析過程
·HTML載入完畢，渲染引擎會在內存中把HTML文檔，生成一個DOM樹，getElementById是獲取內中DOM上的元素節點。然後操作的時候修改的是該元素的屬性。
·DOM樹（一切都是節點）
DOM的數據結構如下：
上圖可知，在HTML當中，一切都是節點：（非常重要）
·元素節點：HMTL標簽。
·文本節點：標簽中的文字（比如標簽之間的空格、換行）
·屬性節點：：標簽的屬性。
整個html文檔就是一個文檔節點。所有的節點都是Object。
（3）DOM可以做什麼
·找對象（元素節點）
·設置元素的屬性值
·設置元素的樣式
·動態創建和刪除元素
·事件的觸發響應：事件源、事件、事件的驅動程序
8. 如何在Python中編寫抽象語法樹的訪問模式
LISP的AST極像代碼是有原因的，LISP用的S-expression本身就是一個中間語言，相當於抽象語法樹生成的中間代碼，用來生成目標代碼的。
本來McCarthy是想用和我們現在使用的語言比較像的M-expression的，但是當時LISP程序員更喜歡用那個中間形式的S-expression，於是就保留下來了。
9. Python中的樹你知道嗎
樹與二叉樹
在了解二叉樹之前，我們要先了解樹的一些概念，方便我們對二叉樹的理解。
什麼是樹？
樹(英語:tree)是一種抽象數據類型(ADT)或是實作這種抽象數據類型的數據結構,用來模擬具有樹狀結構性質的數據集合。
它是由n(n>=1)個有限節點組成一個具有層次關系的集合。把它叫做「樹」是因為它看起來像一棵倒掛的樹,也就是說它是根朝上,而葉朝下的。它具有以下的特點:
每個節點有零個或多個子節點;
沒有父節點的節點稱為根節點;
每一個非根節點有且只有一個父節點;
除了根節點外,每個子節點可以分為多個不相交的子樹;
樹的術語：
節點的度: 一個節點含有的子樹的個數稱為該節點的度;
樹的度: 一棵樹中,最大的節點的度稱為樹的度;
根結點： 樹的最頂端的節點，繼續往下分為子節點
父節點： 子節點的上一層為父節點
兄弟節點： 具有同一個父節點的節點稱為兄弟節點
葉子節點/終端節點： 不再有子節點的節點為葉子節點
二叉樹：
二叉樹是樹的特殊一種，具有如下特點：
每個節點最多有兩個子樹，節點的度最大為2
左子樹和右子樹是有順序的，次序不能顛倒
即是某節點只有一個子樹，也要區分左右子樹
二叉樹的性質：
在非空二叉樹的第i層，最多有2i-1個節點(i>=1)
在深度為K的二叉樹上最多有2k-1個節點(k>.1)
對於任意一個非空的二叉樹，如果葉子節點個數為n0，度數為2的節點數為n2，則有n0=n2+1
推倒過程：在一棵二叉樹中，除了葉子節點（度為0）外，就剩下度為2(n2)和度為1(n1)的節點了。則樹的節點總數為T = n0 + n1 + n2；在二叉樹中節點總數為T，而連線總數為T-1 = 2*n2 + n1，所以就有：n0 + n1 + n2 - 1 = 2 *n2 + n1，得到n0=n2+1。
特殊的二叉樹
滿二叉樹
在二叉樹中除了葉子節點，其他所有節點的度為2，且所有的葉子節點都在同一層上，這樣的二叉樹成為滿二叉樹。
滿二叉樹的特點：
葉子節點只能出現在最下一層
非葉子節點度數一定為2
在同樣深度的二叉樹中，滿二叉樹的節點個數最多，葉子節點數最多
完全二叉樹
如果二叉樹中除去最後一層葉子節點後為滿二叉樹，且最後一層的葉子節點依次從左到右分布，則這樣的二叉樹稱為完全二叉樹
完全二叉樹的特點：
葉子節點一般出現在最下一層，如果倒數第二層出現葉子節點，一定出現在右部連續位置
最下層葉子節點一定集中在左部連續位置
同樣節點的二叉樹，完全二叉樹的深度最小（滿二叉樹也對）
小例題：
某完全二叉樹共有200個節點，該二叉樹中共有（）個葉子節點？
解：n0 + n1 + n2 = 200， 其中n0 = n2 + 1，n1 = 0或者1 （n1=1，出現在最下一層節點數為奇數，最下一層節點數為偶數，則n1=0）， 因為n0為整數，所以最後算得n0 = 100。
完全二叉樹的性質：
具有n個節點的完全二叉樹的深度為log2n+1。log2n結果取整數部分。
如果有一棵有n個節點的完全二叉樹的節點按層次序編號，對任一層的節點i(1 <= i <= n)
1. 如果i=1，則節點是二叉樹的根，無父節點，如果i>1,則其父節點為i/2，向下取整
2. 如果2*1>n，那麼節點i沒有左孩子，否則其左孩子為2i
3. 如果2i+1>n那麼節點沒有右孩子，否則右孩子為2i+1
驗證：
第一條：
當i=1時，為根節點。當i>1時，比如結點為7，他的雙親就是7/2= 3；結點9雙親為4.
第二條：
結點6,62 = 12>10，所以結點6無左孩子，是葉子結點。結點5，52 = 10，左孩子是10,結點4，為8.
第三條：
結點5，2*5+1>10,沒有右孩子，結點4，則有右孩子。
更多Python相關知識，請移步Python視頻教程繼續學習！！
10. 如何在c++和python之間傳遞復雜結構
很多辦法都可以
如果你的c++對象是已有的代碼，可以用cpython包裝成Python對象，這些cpython包裝的對象有一個指針是指向
你要包裝的c++對象的，然後提供訪問c++對象的方法。比如你一顆樹可以包裝成Python對象，樹節點也包裝成Python對象，只要是復雜一點的
c++對象都可以包裝成Python對象。
如果c++部分的代碼還沒寫，可以用cython直接來寫，這樣自動擴展成Python模塊，這樣的模塊通常是對性能要求很高的才需要專門用c擴展
也可以用Python自帶的ctypes模塊直接定義c++ 對象，這種對象是可以直接導到Python使用的。