用python語言寫二叉樹

A. python列印二叉樹所有路徑的主函數怎樣寫

基本演算法就是二叉樹的遍歷，首先想到的是深度優先遍歷。
難缺毀橘點在於，如何實現每個子路徑的記錄和append
binaryTreePaths函數只伏團給了root變數，余衡無法存儲每個子路徑，考慮寫輔助函數res，添加存儲路徑的變數
res(root,temp)
同時還需要一個全局變數result存儲最後的輸出結果，result.append(temp)

B. python 查找二叉樹是否有子樹

python中的二叉樹模塊內容：
BinaryTree：非平衡二叉樹
AVLTree：平衡的AVL樹
RBTree：平衡的紅黑樹
以上是用python寫的，相面的模塊是用c寫的，並且可以做為Cython的包。
FastBinaryTree
FastAVLTree
FastRBTree
特別需要說明的是：樹往往要比python內置的dict類慢一些，但是它中的所有數據都是按照某個關鍵詞進行排序的，故在某些情況下是必須使用的。
安裝和使用
安裝方法
安裝環境：
ubuntu12.04, python 2.7.6

C. python二叉樹問題

def __init__(self ,value=3): # value = default_value
self.value = value

這樣就行了撒。
PS：以後貼代碼記得把縮進對齊。。。

D. Python 二叉樹的創建和遍歷、重建

幾個有限元素的集合，該集合為空或者由一個根（Root）的元素及兩不相交的（左子樹和右子樹）的二叉樹組成，是有序樹，當集合為空時，稱為空二叉樹，在二叉樹中，一個元素也稱為一個結點。

前序遍歷：若二叉樹為空，則空操作返回，否則先訪問根結點，然後前序遍歷左子樹，再前序遍歷右子樹

中序遍歷：若樹為空，則空操作返回，否則從根結點開始（不是先訪問根結點），中序遍歷根結點的左子樹，然後訪問根節點，最後中序遍歷右子樹。

後序遍歷：若樹為空，則空操作返回，否則從左到右先訪問葉子結點後結點的方式遍歷左右子樹，最後訪問根節點。

層序遍歷：若樹為空，則空操作返回，否則從樹的每一層，即從根節點開始訪問，從上到下逐層遍歷，在同一層中，按從左到右的順序對結點逐個訪問。

假設已知後序遍歷和中序遍歷結果，從後序遍歷的結果可以等到最後一個訪問的結點是根節點，對於最簡單的二叉樹，此時在中序遍歷中找到根節點之後，可以分辨出左右子樹，這樣就可以重建出這個最簡單的二叉樹了。而對於更為復雜的二叉樹，重建得到根結點和暫時混亂的左右結點，通過遞歸將左右結點依次重建為子二叉樹，即可完成整個二叉樹的重建。（在得到根結點之後，需要在中序遍歷序列中尋找根結點的位置，並將中序序列拆分為左右部分，所以要求序列中不能有相同的數字，這是序列重建為二叉樹的前提。）

Root =None

strs="abc##d##e##"   #前序遍歷擴展的二叉樹序列

vals =list(strs)

Roots=Create_Tree(Root,vals)#Roots就是我們要的二叉樹的根節點。

print(Roots)

inorderSearch = inOrderTraverse2(Roots)

print(inorderSearch)

E. 如何用python構造一個n層的完全二叉樹

用python構造一個n層的完全二叉蘆褲埋樹的代碼如下：
typedef
struct
{int
weight;int
parent,
lchild,
rchild;
}
htnode
,*huffmantree;
//純賀
動態分配數組存陪螞儲huffman樹
演算法設計void
createhuffmantree(){
ht=(huffmantree)malloc(m+1)*sizeof(htnode.

F. python二叉樹求深度的一個問題，有代碼，求解釋

這是遞歸演算法
我們可以先假設函數功能已經實現，left從左子樹拿到一個深度值，right從右子樹拿到一個深度值，最後，本層的深度為left和right的最大值加1，也就是最大深度值再算上自己這一層。
也可以從停止條件開始思考，什麼時候不再遞歸呢？當root為空時，並返回深度值為0。調用這一層的函數得到返回值就是0，我們假設這是左子樹left得到的值，同時假設右子樹也為空，所以right也為0。那麼返回給上一層的值就是left和right最大值加1，就是1，表示這個節點深度為1。同理，可以得到整棵樹深度。

G. python二叉樹輸出結果為什麼是這樣

1. 二叉樹

二叉樹(binary tree)中的每個節點都不能有多於兩個的兒子。

圖 ((7+3)*(5-2))的表達式樹表示

2.1 根據中綴表達式構造表達式樹：

遍歷表達式：

1.建立一個空樹

2.遇到'('，為當前的Node添加一個left child，並將left child當做當前Node。

3.遇到數字，賦值給當前的Node，並返回parent作為當前Node。

4.遇到('+-*/')，賦值給當前Node，並添加一個Node作為right child，將right child當做當前的Node。

5.遇到')',返回當前Node的parent。

defbuildexpressionTree(exp):tree=BinaryTree('')stack=[]stack.append(tree)currentTree=treeforiinexp:ifi=='(':currentTree.insertLeft('')stack.append(currentTree)currentTree=currentTree.leftChildelifinotin'+-*/()':currentTree.key=int(i)parent=stack.pop()currentTree=parentelifiin'+-*/':currentTree.key=icurrentTree.insertRight('')stack.append(currentTree)currentTree=currentTree.rightChildelifi==')':currentTree=stack.pop()else:raiseValueErrorreturntree

上述演算法對中綴表達式的寫法要求比較繁瑣，小括弧應用太多，例如要寫成(a+(b*c))的形式。

用後綴表達式構建表達式樹會方便一點:如果符號是操作數，建立一個單節點並將一個指向它的指針推入棧中。如果符號是一個操作符，從棧中彈出指向兩棵樹T1和T2的指針並形成一棵新的樹，樹的根為此操作符，左右兒子分別指向T2和T1.

123456789101112131415defbuild_tree_with_post(exp):stack=[]oper='+-*/'foriinexp:ifinotinoper:tree=BinaryTree(int(i))stack.append(tree)else:righttree=stack.pop()lefttree=stack.pop()tree=BinaryTree(i)tree.leftChild=lefttreetree.rightChild=righttreestack.append(tree)returnstack.pop()

3.樹的遍歷

3.1 先序遍歷(preorder travelsal)

先列印出根，然後遞歸的列印出左子樹、右子樹，對應先綴表達式

12345678defpreorder(tree,nodelist=None):ifnodelistisNone:nodelist=[]iftree:nodelist.append(tree.key)preorder(tree.leftChild,nodelist)preorder(tree.rightChild,nodelist)returnnodelist

3.2 中序遍歷(inorder travelsal)

先遞歸的列印左子樹，然後列印根，最後遞歸的列印右子樹，對應中綴表達式

12345definorder(tree):iftree:inorder(tree.leftChild)printtree.keyinorder(tree.rightChild)

3.3 後序遍歷(postorder travelsal)

遞歸的列印出左子樹、右子樹，然後列印根，對應後綴表達式

1234567defpostorder(tree):iftree:forkeyinpostorder(tree.leftChild):yieldkeyforkeyinpostorder(tree.rightChild):yieldkeyyieldtree.key

3.4 表達式樹的求值

1234567891011defpostordereval(tree):operators={'+':operator.add,'-':operator.sub,'*':operator.mul,'/':operator.truediv}leftvalue=Nonerightvalue=Noneiftree:leftvalue=postordereval(tree.leftChild)rightvalue=postordereval(tree.rightChild)ifleftvalueandrightvalue:returnoperators[tree.key](leftvalue,rightvalue)else:returntree.key

H. 一道演算法題，用python初始化一顆二叉樹並求解其最短路徑的值

二叉樹演算法，可能按照你的需求不是很多：
下面是我用的一個，不過你可以借鑒一下的：
# -*- coding: cp936 -*-
import os
class Node(object):
"""docstring for Node"""
def __init__(self, v = None, left = None, right=None, parent=None):
self.value = v
self.left = left
self.right = right
self.parent = parent
class BTree(object):
"""docstring for BtTee """
def __init__(self):
self.root = None
self.size = 0
def insert(self, node):
n = self.root
if n == None:
self.root = node
return
while True:
if node.value <= n.value:
if n.left == None:
node.parent = n
n.left = node
break
else:
n = n.left
if node.value > n.value:
if n.right == None:
n.parent = n
n.right = node
break
else:
n = n.right
def find(self, v):
n = self.root # http://yige.org
while True:
if n == None:
return None
if v == n.value:
return n
if v < n.value:
n = n.left
continue
if v > n.value:
n = n.right
def find_successor(node):
'''查找後繼結點'''
assert node != None and node.right != None
n = node.right
while n.left != None:
n = n.left
return n
def delete(self, v):
n = self.find(v)
print "delete:",n.value
del_parent = n.parent
if del_parent == None:
self.root = None;
return
if n != None:
if n.left != None and n.right != None:
succ_node = find_successor(n)
parent = succ_node.parent
if succ_node == parent.left:
#if succ_node is left sub tree
parent.left = None
if succ_node == parent.right:
#if succ_node is right sub tree
parent.right = None
if del_parent.left == n:
del_parent.left = succ_node
if del_parent.right == n:
del_parent.right = succ_node
succ_node.parent = n.parent
succ_node.left = n.left
succ_node.right = n.right
del n
elif n.left != None or n.right != None:
if n.left != None:
node = n.left
else:
node = n.right
node.parent = n.parent
if del_parent.left == n:
del_parent.left = node
if del_parent.right == n:
del_parent.right = node
del n
else:
if del_parent.left == n:
del_parent.left = None
if del_parent.right == n:
del_parent.right = None
def tranverse(self):
def pnode(node):
if node == None:
return
if node.left != None:
pnode(node.left)
print node.value
if node.right != None:
pnode(node.right)
pnode(self.root)
def getopts():
import optparse, locale
parser = optparse.OptionParser()
parser.add_option("-i", "--input", dest="input", help=u"help name", metavar="INPUT")
(options, args) = parser.parse_args()
#print options.input
return (options.input)
if __name__ == '__main__':
al = [23, 45, 67, 12, 78,90, 11, 33, 55, 66, 89, 88 ,5,6,7,8,9,0,1,2,678]
bt = BTree()
for x in al :
bt.insert(Node(x))
bt.delete(12)
bt.tranverse()
n = bt.find(12)
if n != None:
print "find valud:",n.value

I. python 二叉樹實現四則運算

#!/usr/bin/python#* encoding=utf-8s = "20-5*(0+1)*5^(6-2^2)" c = 0top = [0,s[c],0]op = [["0","1","2","3","4","5","6","7","8","9"],["+","-"],["*","/"],["^"]] def getLev(ch): for c1 in range(0, len(op)): for c2 in range(0, len(op[c1])): if (op[c1][c2]==ch): return c1 elif (len(ch)>1): match = 0 for c3 in range(0, len(ch)): if (getLev(ch[c3])>=0): match+=1 if (match==len(ch)):return c1 return -1