二叉樹的查詢Python

㈠ python 二叉樹是怎麼實現的

#coding:utf-8
#author:Elvis

classTreeNode(object):
def__init__(self):
self.data='#'
self.l_child=None
self.r_child=None

classTree(TreeNode):
#createatree
defcreate_tree(self,tree):
data=raw_input('->')
ifdata=='#':
tree=None
else:
tree.data=data
tree.l_child=TreeNode()
self.create_tree(tree.l_child)
tree.r_child=TreeNode()
self.create_tree(tree.r_child)

#visitatreenode
defvisit(self,tree):
#輸入#號代表空樹
iftree.dataisnot'#':
printstr(tree.data)+'	',
#先序遍歷
defpre_order(self,tree):
iftreeisnotNone:
self.visit(tree)
self.pre_order(tree.l_child)
self.pre_order(tree.r_child)

#中序遍歷
defin_order(self,tree):
iftreeisnotNone:
self.in_order(tree.l_child)
self.visit(tree)
self.in_order(tree.r_child)

#後序遍歷
defpost_order(self,tree):
iftreeisnotNone:
self.post_order(tree.l_child)
self.post_order(tree.r_child)
self.visit(tree)

t=TreeNode()
tree=Tree()
tree.create_tree(t)
tree.pre_order(t)
print'
'
tree.in_order(t)
print'
'
tree.post_order(t)

㈡ 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)

㈢ 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

㈣ python 二叉樹實現思想

第一 ：return 的縮進不對 ，

ifself.root==None:
self.root=node
return#如果這里不縮進，下面的語句無意義，直接返回，不會執行。

while queue這個循環的作用的是從root根結點開始，向下查找第一個左(右)子結點為空的結點，將node插入這個位置,queue的作用是將查找到的非空子結點保存在queue中，然後依次向下查找這些子結點的左右子結點

㈤ python 如何將一段字元串用二叉樹的後序遍歷列印出來

# -*- coding:utf-8 -*-def fromFMtoL( mid ): global las #全局後序遍歷 global fir #先序遍歷 root = fir[0] #取出當前樹根 fir = fir[1:] #取出樹根後 先序遍歷把根拿出來 下面一個元素做樹根 root_po = mid.find( root ) #在中序遍歷當中樹根的位置 left = mid[0:root_po] #左子樹 right = mid[root_po+1:len(mid)] #右子樹 ''' 後序遍歷： 左 右 根 先左子樹 再右子樹 最後跟 ''' #有左子樹的時候 if len(left) > 0: fromFMtoL( left ) #有右子樹的時候 if len(right) > 0: fromFMtoL( right ) #樹根寫進結果 las += rootif __name__ == "__main__" : # fir = input("請輸入先序遍歷：") #前序遍歷的結果 # mid = input("請輸入中序遍歷：") #中序遍歷的結果 fir = "DBACEGF" mid = "ABCDEFG" # fir = "ABC" # mid = "BAC" las = "" fromFMtoL( mid ) print(las)

㈥ python 查找二叉樹是否有子樹

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

㈦ 求Python二叉樹的幾個演算法 求幾個二叉樹的method！ 1) 給一個值，然後在樹中找出該值

你好：

二叉樹演算法，網上是比較多的；

可能按照你的需求不是很多：

下面是我用的一個，不過你可以借鑒一下的：

#-*-coding:cp936-*-
importos
classNode(object):
"""docstringforNode"""
def__init__(self,v=None,left=None,right=None,parent=None):
self.value=v
self.left=left
self.right=right
self.parent=parent
classBTree(object):
"""docstringforBtTee"""
def__init__(self):
self.root=None
self.size=0
definsert(self,node):
n=self.root
ifn==None:
self.root=node
return
whileTrue:
ifnode.value<=n.value:
ifn.left==None:
node.parent=n
n.left=node
break
else:
n=n.left
ifnode.value>n.value:
ifn.right==None:
n.parent=n
n.right=node
break
else:
n=n.right
deffind(self,v):
n=self.root#http://yige.org
whileTrue:
ifn==None:
returnNone
ifv==n.value:
returnn
ifv<n.value:
n=n.left
continue
ifv>n.value:
n=n.right
deffind_successor(node):
'''查找後繼結點'''
assertnode!=Noneandnode.right!=None
n=node.right
whilen.left!=None:
n=n.left
returnn
defdelete(self,v):
n=self.find(v)
print"delete:",n.value
del_parent=n.parent
ifdel_parent==None:
self.root=None;
return
ifn!=None:
ifn.left!=Noneandn.right!=None:
succ_node=find_successor(n)
parent=succ_node.parent
ifsucc_node==parent.left:
#ifsucc_nodeisleftsubtree
parent.left=None
ifsucc_node==parent.right:
#ifsucc_nodeisrightsubtree
parent.right=None
ifdel_parent.left==n:
del_parent.left=succ_node
ifdel_parent.right==n:
del_parent.right=succ_node
succ_node.parent=n.parent
succ_node.left=n.left
succ_node.right=n.right
deln
elifn.left!=Noneorn.right!=None:
ifn.left!=None:
node=n.left
else:
node=n.right
node.parent=n.parent
ifdel_parent.left==n:
del_parent.left=node
ifdel_parent.right==n:
del_parent.right=node
deln
else:
ifdel_parent.left==n:
del_parent.left=None
ifdel_parent.right==n:
del_parent.right=None
deftranverse(self):
defpnode(node):
ifnode==None:
return
ifnode.left!=None:
pnode(node.left)
printnode.value
ifnode.right!=None:
pnode(node.right)
pnode(self.root)
defgetopts():
importoptparse,locale
parser=optparse.OptionParser()
parser.add_option("-i","--input",dest="input",help=u"helpname",metavar="INPUT")
(options,args)=parser.parse_args()
#printoptions.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()
forxinal:
bt.insert(Node(x))
bt.delete(12)
bt.tranverse()
n=bt.find(12)
ifn!=None:
print"findvalud:",n.value

㈧ 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

㈨ python二叉樹演算法

定義一顆二叉樹，請看官自行想像其形狀

class BinNode( ):
def __init__( self, val ):
self.lchild = None
self.rchild = None
self.value = val

binNode1 = BinNode( 1 )
binNode2 = BinNode( 2 )
binNode3 = BinNode( 3 )
binNode4 = BinNode( 4 )
binNode5 = BinNode( 5 )
binNode6 = BinNode( 6 )

binNode1.lchild = binNode2
binNode1.rchild = binNode3
binNode2.lchild = binNode4
binNode2.rchild = binNode5
binNode3.lchild = binNode6