树的python实现

from collections import deque
import queue
class TreeNode():
	def __init__(self, x):
		self.val = x
		self.left=None
		self.right=None

class Tree(object):
	"""docstring for Tree"""
	def __init__(self):
		super(Tree, self).__init__()
		self.root = None         #树是由根节点表示的

	def construct_tree(self,values=None):    #给定一个数组构造树
		if not values:
			return None
		self.root=TreeNode(values[0])
		que=deque()
		que.append(self.root)
		size=len(values)
		nums=1
		while nums<size:
			node=que.popleft()#最先进队列的出队列
			if node:    # 结点非空
				node.left=TreeNode(values[nums])
				que.append(node.left)
				if nums+1<size:  #最后一个节点是右节点，nums+1为当前左子节点，当前左子节点不是最后一个节点，即当前的节点还有右子节点
					node.right=TreeNode(values[nums+1])
					que.append(node.right)
					nums+=1          #统计了右子节点了
				nums+=1          #统计了左子节点了
	#广度优先遍历
	def bfs(self):
		lst=[]
		queue=deque([self.root])
		while queue:
			node=queue.popleft()
			if node:
				lst.append(node.val)
				queue.append(node.left)
				queue.append(node.right)
		return lst

	#分层的层次遍历
	def bfs_(self):
		levels = []
		if not self.root:
			return levels
        
		level = 0
		que = deque()
		que.append(self.root)
		while que:
            # start the current level
			levels.append([])
            # number of elements in the current level 
			level_length = len(que)
			for i in range(level_length):
				node = que.popleft()
				levels[level].append(node.val)
				if node.left:
					que.append(node.left)
				if node.right:
					que.append(node.right)

			level += 1
		return levels
	
	#前序遍历
	def preorder(self):
		lst = []
		def order(head):
			if not head:
				return
			lst.append(head.val)
			order(head.left)
			order(head.right)
		order(self.root)
		return lst

	#中序遍历
	def midorder(self):
		lst = []
		def order(head):
			if not head:
				return		
			order(head.left)
			lst.append(head.val)
			order(head.right)
		order(self.root)
		return lst

	#后序遍历
	def endorder(self):
		lst = []
		def order(head):
			if not head:
				return			
			order(head.left)
			order(head.right)
			lst.append(head.val)
		order(self.root)
		return lst

	#判断是否对称_递归
	def Issymmetric(self):
		if not self.root:
			return True
		def LeqR(Lnode,Rnode):
			if Lnode or Rnode:				
				if Rnode and Lnode:
					if Lnode.val==Rnode.val:
						return LeqR(Lnode.left,Rnode.right) and LeqR(Lnode.right,Rnode.left)
					else:
						return False
				else:
					return False
			else:
				return True
		return(LeqR(self.root.left,self.root.right))

	#判断是否对称_迭代
	def Issymmetric_(self):
		if not self.root:
			return True
		que=queue.Queue()
		que.put(self.root)
		que.put(self.root)
		while (not que.empty()):
			Lnode=que.get()
			Rnode=que.get()
			if Lnode==None and Rnode==None:
				continue
			if Lnode==None or Rnode==None:
				return False
			if Lnode.val!=Rnode.val:
				return False
			que.put(Lnode.left)
			que.put(Rnode.right)
			que.put(Lnode.right)
			que.put(Rnode.left)
		return True
#Test
root = [1,2,None,3,None,4,None,5]
T=Tree()
T.construct_tree(root)
print(T.bfs())
print(T.bfs_())

————————————————
积跬步，以至千里