python实现抽象数据类型=＞二叉树

class TreeNode:
	"""
	节点类
	"""
	def __init__(self, val=None, left=None, right=None):
		self.val = val
		self.left = left
		self.right = right
		
class Tree:
	"""
	二叉树类
	"""
	def __init__(self, maxNodes):
		self.root = None
		self.nodes = [TreeNode() for _ in range(maxNodes)]
		self.nodeSize = maxNodes
		
	def GetTreeNode(self, id):
		"""
		根据节点索引获取节点
		"""
		return self.nodes[id]
		
	def visit(self, node):
		"""
		返回节点的值
		"""
		print(node.val, end="")
		
	def Create(self, a, size, nodeId):
		"""
		往节点里面填数组的值
		a: 数组
		size: 数组的长度
		nodeId: 指定的根节点在数组中的索引
		"""
		if nodeId >= size or a[nodeId] == None:
			return None
		nowNode = self.GetTreeNode(nodeId)
		nowNode.val = a[nodeId]
		nowNode.left = self.Create(a, size, nodeId*2)
		nowNode.right = self.Create(a, size, nodeId*2+1)
		return nowNode
		
	def CreateTree(self, a):
		"""
		往节点里面填数组的值
		a: 数组
		"""
		self.root = self.Create(a, len(a), 1)
		
	def preOrder(self, node):
		"""
		先序遍历
		"""
		if node:
			self.visit(node)
			self.preOrder(node.left)
			self.preOrder(node.right)
			
	def preOrderTraversal(self):
		"""
		先序遍历
		"""
		self.preOrder(self.root)
		print("")
		
	def inOrder(self, node):
		"""
		中序遍历
		"""
		if node:
			self.inOrder(node.left)
			self.visit(node)
			self.inOrder(node.right)
			
	def inOrderTraversal(self):
		"""
		中序遍历
		"""
		self.inOrder(self.root)
		print("")
		
	def postOrder(self, node):
		"""
		后序遍历
		"""
		if node:
			self.postOrder(node.left)
			self.postOrder(node.right)
			self.visit(node)
			
	def postOrderTraversal(self):
		"""
		后序遍历
		"""
		self.postOrder(self.root)
		print("")
		
def test():
	a = [None, 'a', 'b', 'c', 'd', None, 'e', 'f', 'g', \
		'h', None, None, None, None, 'i']
	t = Tree(15)
	t.CreateTree(a)
	t.preOrderTraversal()
	t.inOrderTraversal()
	t.postOrderTraversal()
		
test()