python二叉树实现

#结点类
class Node(object):
	def __init__(self,value):
		self.value = value
		self.lchild = None
		self.rchild = None

class BiTree(object):
	'''
	二叉树
	'''
	#初始化根节点
	def __init__(self):
		self.root = None

	#增加结点
	def addNode(self,value):
		node = Node(value)
		if self.root is None:
			self.root = node
			return 
		queue = [self.root]
		while queue:
			r = queue.pop(0)
			if r.lchild is None:
				r.lchild = node
				return
			else:
				queue.append(r.lchild)
			if r.rchild is None:
				r.rchild = node
				return 
			else:
				queue.append(r.rchild)

	#二叉排序树
	def Insert(self,value):
		self.InsertNode(value,self.root)

	def InsertNode(self,value,btnode):
		node = Node(value)
		if self.root is None:
			self.root = node
			return 
		if btnode is None:
			btnode = Node(value)
			return 
		elif value < btnode.value:
			if btnode.lchild == None:
				btnode.lchild = Node(value)
				return
			self.InsertNode(value,btnode.lchild)
		elif value >btnode.value:
			if btnode.rchild == None:
				btnode.rchild = Node(value)
				return
			self.InsertNode(value,btnode.rchild)


    
	#层序遍历				
	def breadth_travel(self):
		'''
		广度遍历 层序遍历
		''' 
		if self.root is None:
			return 
		queue = [self.root]
		while queue:
			r = queue.pop(0)
			print(r.value,end=" ")
			if r.lchild is not None:
				queue.append(r.lchild)
			if r.rchild is not None:
				queue.append(r.rchild)

	#前序遍历递归实现
	def PreOrder(self,root):
		if root == None:
			return 
		print(root.value,end=" ")
		self.PreOrder(root.lchild)
		self.PreOrder(root.rchild)

	#前序遍历非递归实现	
	def PreOrder_nonRecursion(self,root):
		if root == None:
			return 
		stack = []
		#res   = []
		r     = self.root
		while r or stack:
			while r:
				#res.append(r.value)
				print(r.value,end=" ")
				stack.append(r)
				r= r.lchild
			r = stack.pop()
			r = r.rchild
		#print(res)

	#中序遍历递归实现
	def InOrder(self,root):
		if root == None:
			return 
		self.InOrder(root.lchild)
		print(root.value,end=" ")
		self.InOrder(root.rchild)

	#中序遍历非递归实现
	def InOrder_nonRecursion(self,root):
		if root == None:
			return
		r     = root
		stack = []
		#res   = []
		while r or stack:
			while r:
				stack.append(r)
				r = r.lchild
			r = stack.pop()
			#res.append(r.value) 
			print(r.value,end=" ")
			r = r.rchild
		#print(res)

	#后序遍历递归实现
	def PostOrder(self,root):
		if root == None:
			return 
		self.PostOrder(root.lchild)
		self.PostOrder(root.rchild)
		print(root.value,end=" ")

	#后序遍历非递归实现
	def PostOrder_nonRecursion(self,root):
		if root == None:
			return
		stack = []
		seq = []
		r = root
		while r or stack:
			while r:
				seq.append(r.value)
				stack.append(r)
				r = r.rchild
			r = stack.pop()
			r = r.lchild
		while seq:
			print(seq.pop(),end=" ")


	#叶子结点
	def PrintLeafNode(self,root):
		if root == None:
			return
		if(root.lchild == None) and (root.rchild == None):
			print(root.value,end=" ")
		self.PrintLeafNode(root.lchild)
		self.PrintLeafNode(root.rchild)

	#求二叉树的高度
	def Height(self,root):
		if root == None:
			return 0
		l = self.Height(root.lchild)
		r = self.Height(root.rchild)
		return l+1 if l>r else r+1


if __name__ == "__main__":
	#此树的结构为
	#      5
	#   1     4
	# 6  7
	tree = BiTree()
	tree.addNode(5)
	tree.addNode(1)
	tree.addNode(4)
	tree.addNode(6)
	tree.addNode(7)
	print("层序遍历实现是",end=" ")
	tree.breadth_travel()
	print("\n前序遍历递归实现是",end=" ")
	tree.PreOrder(tree.root)
	print("\n中序遍历递归实现是",end=" ")
	tree.InOrder(tree.root)
	print("\n后序遍历递归实现是",end=" ")
	tree.PostOrder(tree.root)
	print("\n叶子结点是:",end=" ")
	tree.PrintLeafNode(tree.root)
	print("\n高度是",tree.Height(tree.root))
	print("前序遍历非递归实现是",end=" ")
	tree.PreOrder_nonRecursion(tree.root)
	print("\n中序遍历非递归实现是",end=" ")
	tree.InOrder_nonRecursion(tree.root)
	print("\n后序遍历非递归实现是",end=" ")
	tree.PostOrder_nonRecursion(tree.root)
	print(" ")
	print(" ")
	#此树的结构为
	#         5
	#     1      6
	#  X   4   X   7
	# X代表无元素
	t2 = BiTree()
	t2.Insert(5)
	t2.Insert(1)
	t2.Insert(6)
	t2.Insert(4)
	t2.Insert(7)
	print("层序遍历实现是",end=" ")
	t2.breadth_travel()
	print("\n前序遍历递归实现是",end=" ")
	t2.PreOrder(t2.root)
	print("\n中序遍历递归实现是",end=" ")
	t2.InOrder(t2.root)
	print("\n后序遍历递归实现是",end=" ")
	t2.PostOrder(t2.root)
	print("\n叶子结点是:",end=" ")
	t2.PrintLeafNode(t2.root)
	print("\n高度是",t2.Height(t2.root))
	print("前序遍历非递归实现是",end=" ")
	t2.PreOrder_nonRecursion(t2.root)
	print("\n中序遍历非递归实现是",end=" ")
	t2.InOrder_nonRecursion(t2.root)
	print("\n后序遍历非递归实现是",end=" ")
	t2.PostOrder_nonRecursion(t2.root)
	print(" ")

Sublime下的结果图：