class BTree:
def __init__(self, value):
self.root = value
self.left = None
self.right = None
#前序遍历:中左右
def preorder(self):
if self.root:
print(self.root, end=' ')
if self.left:
self.left.preorder()
if self.right:
self.right.preorder()
#中序遍历:左中右
def inorder(self):
if self.left:
self.left.inorder()
if self.root:
print(self.root, end=" ")
if self.right:
self.right.inorder()
#后序遍历:左右中
def postorder(self):
if self.left:
self.left.postorder()
if self.right:
self.right.postorder()
if self.root:
print(self.root, end=" ")
#层序遍历
def levelorder(self):
level_order = []
if self.root:
level_order.append([self])
height = self.height()
if height >= 1:
for _ in range(2, height + 1):
level = []
for node in level_order[-1]:
if node.left:
level.append(node.left)
if node.right:
level.append(node.right)
if level:
level_order.append(level)
for i in range(0, height):
for index in range(len(level_order[i])):
level_order[i][index] = level_order[i][index].root
return level_order
#设置高度
def height(self):
if self.root is None:
return 0
elif self.left is None and self.right is None:
return 1
elif self.left is None and self.right:
return 1 + self.right.height()
elif self.left and self.right is None:
return 1 + self.left.height()
else:
return 1 + max(self.left.height(), self.right.height())
#对树的叶子进行遍历
def leaves(self):
if self.root is None:
return
elif self.left is None and self.right is None:
print(self.root, end=' ')
elif self.left is None and self.right:
self.right.leaves()
elif self.right is None and self.left:
self.left.leaves()
else:
self.left.leaves()
self.right.leaves()
非递归方法实现:
class TreeNode:
def __init__(self, x, L=None, R=None):
self.val = x
self.left = L
self.right = R
#前序遍历:根左右
class Solution:
def preordder(self,root):
temp=[root]
dp=[]
while temp:
tmp=temp.pop()
dp.append(tmp.val)
if tmp.right:
temp.append(tmp.right)
if tmp.left:
temp.append(tmp.left)
return dp
#中序遍历:左根右:
'''先定义两个空列表,
设置变量存储根节点,再对定义的空列表和当前变量进行遍历,将第一个空列表用来存储根节点,然后返回到左节点,定义变量=第一个列表删除的元素
第二个元素用来存储当前的删除的节点值,设置变量将其传给当前根节点的右孩子,最后返回遍历的数据列表
'''
class Solution1:
def middleorder(self,root):
stack=[]
res=[]
r=root
while stack or r:
if r:
stack.append(r)
r=r.left
else:
node=stack.pop()
res.append(node.val)
r=node.right
return res
#后序遍历:左右根:
'''
先设置两个空数组用于后续读取和设置遍历的节点,
先将根节点传给其中一个数组进行存储
设置一个循环,其中设置变量等于根节点中弹出的一个元素,
并在另一个空数组中添加当前弹出元素的节点
后走到左孩子,将根节点树的左孩子传给第一个数组,并且添加进去
随后看右孩子,再将右孩子添加到第一个数组
最后将该结果返回到第二个空数组即可
'''
class Solution2:
def backorder(self,root):
dp1=[root]
dp2=[]
while dp1:
cur=dp1.pop()
dp2.append(cur.val)
if cur.left:
dp1.append(cur.left)
if cur.right:
dp1.append(cur.right)
return dp2[-1]
#层序遍历:对每层元素开始遍历
'''
先设置空的数组,将根节点添加一个数组中方便后续遍历
设置while循环对每层进行遍历,将每层的节点元素弹出后存入一个空的数组,
最后将每层的元素进行遍历和存储
'''
class Solution3:
def levelbianli(self,root):
outlist1=[]
outlist2=[]
outlist1.append(root)
while outlist1:
res=[]
i=0
temp=outlist1.pop(0)
res.append(temp.val)
nums=len(outlist1)
while i<nums:
p=outlist1.pop(0)
res.append(p.val)
if p.left:
outlist1.append(p.left)
if p.right:
outlist1.append(p.right)
i+=1
outlist2.append(res)
return outlist2