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使用的。