python 组织结构树_Python数据结构之树

二叉树

嵌套列表方式

# coding:utf-8

# 列表嵌套法

def BinaryTree(r):

return [r, [], []]

def insertLeft(root, newBranch):

t = []

if root != []:

t = root.pop(1)

if len(t) > 1:

root.insert(1, [newBranch, t, []])

else:

root.insert(1, [newBranch, [], []])

return root

def insertRight(root, newBranch):

t = []

if root != []:

t = root.pop(2)

if len(t) > 1:

root.insert(2, [newBranch, [], t])

else:

root.insert(2, [newBranch, [], []])

return root

def getRootVal(root):

return root[0]

def setRootVal(root, newVal):

root[0] = newVal

def getLeftChild(root):

return root[1]

def getRightChild(root):

return root[2]

if __name__ == ‘__main__‘:

r = BinaryTree(‘a‘)

insertLeft(r, ‘b‘)

insertRight(r, ‘c‘)

insertRight(getLeftChild(r), ‘d‘)

insertLeft(getRightChild(getRightChild(r)), ‘e‘)

print(r)

结点方式

class BinaryTree:

"""

A recursive implementation of Binary Tree

Using links and Nodes approach.

Modified to allow for trees to be constructed from other trees rather than always creating

a new tree in the insertLeft or insertRight

"""

def __init__(self,rootObj):

self.key = rootObj

self.leftChild = None

self.rightChild = None

def insertLeft(self,newNode):

if isinstance(newNode, BinaryTree):

t = newNode

else:

t = BinaryTree(newNode)

if self.leftChild is not None:

t.left = self.leftChild

self.leftChild = t

def insertRight(self,newNode):

if isinstance(newNode,BinaryTree):

t = newNode

else:

t = BinaryTree(newNode)

if self.rightChild is not None:

t.right = self.rightChild

self.rightChild = t

def isLeaf(self):

return ((not self.leftChild) and (not self.rightChild))

def getRightChild(self):

return self.rightChild

def getLeftChild(self):

return self.leftChild

def setRootVal(self,obj):

self.key = obj

def getRootVal(self,):

return self.key

def inorder(self):

if self.leftChild:

self.leftChild.inorder()

print(self.key)

if self.rightChild:

self.rightChild.inorder()

def postorder(self):

if self.leftChild:

self.leftChild.postorder()

if self.rightChild:

self.rightChild.postorder()

print(self.key)

def preorder(self):

print(self.key)

if self.leftChild:

self.leftChild.preorder()

if self.rightChild:

self.rightChild.preorder()

def printexp(self):

if self.leftChild:

print(‘(‘, end=‘ ‘)

self.leftChild.printexp()

print(self.key, end=‘ ‘)

if self.rightChild:

self.rightChild.printexp()

print(‘)‘, end=‘ ‘)

def postordereval(self):

opers = {‘+‘:operator.add, ‘-‘:operator.sub, ‘*‘:operator.mul, ‘/‘:operator.truediv}

res1 = None

res2 = None

if self.leftChild:

res1 = self.leftChild.postordereval() #// \label{peleft}

if self.rightChild:

res2 = self.rightChild.postordereval() #// \label{peright}

if res1 and res2:

return opers[self.key](res1,res2) #// \label{peeval}

else:

return self.key

def inorder(tree):

if tree != None:

inorder(tree.getLeftChild())

print(tree.getRootVal())

inorder(tree.getRightChild())

def printexp(tree):

if tree.leftChild:

print(‘(‘, end=‘ ‘)

printexp(tree.getLeftChild())

print(tree.getRootVal(), end=‘ ‘)

if tree.rightChild:

printexp(tree.getRightChild())

print(‘)‘, end=‘ ‘)

def printexp(tree):

sVal = ""

if tree:

sVal = ‘(‘ + printexp(tree.getLeftChild())

sVal = sVal + str(tree.getRootVal())

sVal = sVal + printexp(tree.getRightChild()) + ‘)‘

return sVal

def postordereval(tree):

opers = {‘+‘:operator.add, ‘-‘:operator.sub, ‘*‘:operator.mul, ‘/‘:operator.truediv}

res1 = None

res2 = None

if tree:

res1 = postordereval(tree.getLeftChild()) #// \label{peleft}

res2 = postordereval(tree.getRightChild()) #// \label{peright}

if res1 and res2:

return opers[tree.getRootVal()](res1,res2) #// \label{peeval}

else:

return tree.getRootVal()

def height(tree):

if tree == None:

return -1

else:

return 1 + max(height(tree.leftChild),height(tree.rightChild))