6.1 数据结构---树（遍历）
一、树的定义
1.定义
树是n(n>=0)个节点的有限集，且这些节点满足如下关系：
（1）有且仅有一个节点没有父节点，该节点称为树的根；
（2）除根外，其余的每个节点都有且仅有一个父节点；
（3）树中的每一个节点都构成一个以它为根的树。
二叉树在满足树的条件时，满足如下条件：每个节点最多有两个孩子（子树），这两个子树有左右之分，次序不可颠倒。
2.树的遍历
二、先序遍历
1.先序遍历
递归
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def preorderTraversal(self,root):
'''
递归,时间复杂度O(n),空间复杂度平均O(logn),最坏情况下O(n)
:param root:
:return:
'''
if root:
print(root.val)
else:
return
self.preorderTraversal(root.left)
self.preorderTraversal(root.right)
非递归：时间复杂度O(n),空间复杂度O(n)
思路:
1)申请一个新的栈,把头结点压入栈中
2)从栈中弹出栈顶节点,记为node,然后打印node节点的值,再将节点node的由孩子先压入stack中,最后将node的左孩子压入stack中
3)不断重复步骤2,直到栈为空,过程结束
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def preorderTraversal1(self,root):
'''
:param root:
:return:
'''
if root == None:
return
res = []
stack = [root]
while stack:
node = stack.pop()
print(node.val)
res.append(node.val)
if node.right:
stack.append(node.right)
if node.left:
stack.append(node.left)
return res
2.左叶子之和
leetcode 404
3.判断一棵树是不是平衡树
4.复制二叉树
5.求二叉树的所有叶子节点，并且判断两棵二叉树的叶子节点是否相等
思路1：用先序遍历按左到右顺序遍历所有叶子节点，并返回，然后判断两棵树的叶子序列是否相等。
时间复杂度O(T1+T2) 空间复杂度O(T1+T2)
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def leafSimilar(self, root1: TreeNode, root2: TreeNode) -> bool:
values1,values2=[],[]
self.printleaf(root1,values1)
self.printleaf(root2,values2)
if values1 == values2:
return True
else:
return False
def printleaf(self,root,values):
if root == None:
return
if root.left == None and root.right == None:
values.append(root.val)
self.printleaf(root.left,values)
self.printleaf(root.right,values)
思路2：dfs
class Solution:
def leafSimilar(self, root1, root2):
def dfs(node):
if node:
if not node.left and not node.right:
yield node.val
yield from dfs(node.left)
yield from dfs(node.right)
return list(dfs(root1)) == list(dfs(root2))
三、中序遍历
1.中序遍历
递归：时间复杂度O(n),空间复杂度平均O(logn),最坏情况下O(n)
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def inorderTraversal(self,root):
'''
:param root:
:return:
'''
if root == None:
return
self.inorderTraversal(root.left)
print(root.val)
self.inorderTraversal(root.right)
非递归：时间复杂度O(n),空间复杂度O(n)
思路:
1)申请一个新的栈,初始时,令变量node=head
2)先把node节点压入栈中,对以node节点为头的整棵子树来说,依次把左边界压入栈中,即不停的令node=node.left,然后重复步骤2
3)不断重复步骤2,直到发现node为空,此时,从栈中弹出一个节点,记为node,打印node的值,并且让node=node.right,然后继续重复步骤2
4)当stack为空且cur为空时,整个过程停止.
class Solution:
def inorderTraversal1(self,root):
'''
:param root:
:return:
'''
if root == None:
return
res = []
stack = []
node = root
while stack or node:
if node:
stack.append(node)
node = node.left
else:
node = stack.pop()
res.append(node.val)
node = node.right
return res
2.判断一棵树是不是二叉搜索树
3.在二叉排序树中找出第一个大于中间值的借贷
4.二叉树转换为双向链表
四、后序遍历
1.后序遍历
递归：时间复杂度O(n),空间复杂度平均O(logn),最坏情况下O(n)
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def posorderTraversal(self,root):
'''
:param root:
:return:
'''
if root == None:
return
self.posorderTraversal(root.left)
self.posorderTraversal(root.right)
print(root.val)
非递归
a.两个栈：时间复杂度O(n),空间复杂度O(n)
思路：用两个栈实现后序遍历
1)申请一个栈,记为s1,然后将头结点head压入栈Ss1中;
2)从s1中弹出的节点记为cur,然后依次将cur的左孩子和右孩子压入s1中;
3)从整个过程中,每一个从s1中弹出的节点都放进s2中;
4)不断重复步骤2和步骤3,直到s1为空,过程停止;
5)从s2中依次弹出节点并打印,打印的顺序就是后序遍历的顺序.
class Solution:
def posorderTraversal1(self,root):
'''
:param root:
:return:
'''
if not root:
return []
s1,s2 = [root],[]
while s1:
cur = s1.pop()
s2.append(cur.val)
if cur.left:
s1.append(cur.left)
if cur.right:
s1.append(cur.right)
return s2[::-1]
b.一个栈
思路：用一个栈实现后序遍历
申请一个栈,将头结点压入栈中,同时设置变量h和c,h代表最近一次弹出并打印的节点,c代表stack的栈顶节点,初始时h为头结点,c为null
def posorderTraversal2(self,root):
'''
:param root:
:return:
'''
if not root:
return []
res = []
cur = [root]
while cur:
node = cur[-1]
if node.left and node.left != root and node.right != root:
cur.append(node.left)
elif node.right and node.right != root:
cur.append(node.right)
else:
res.append(cur.pop().val)
root = node
return res
2.二叉树的最小深度
leetcode 111
3.判断一个数组是否是二元查找树后序遍历的序列
4.对二叉树进行镜像反转
5.求二叉树的最大子树和
五、层次遍历
1.层次遍历
递归
思路：每次遍历到新层，层数+1,
class Solution:
def levelOrder(self,root,level,result):
'''
递归,按层输出
:param root:
:param level:
:param result:
:return:
'''
if root == None:
return
if level == len(result): # 如果遍历到了新层,就新建一个[]用来存放新层的值
result.append([])
result[level].append(root.val)
if root.left:
self.levelOrder(root.left,level+1,result)
if root.right:
self.levelOrder(root.right,level+1,result)
def levelOrder1(self, root):
"""
:type root: TreeNode
:rtype: List[List[int]]
"""
level,result = 0,[]
self.levelOrder(root,level,result)
return result
非递归
思路：用一个队列记录
def levelOrder2(self,root):
'''
思路:队列
用队列存储节点,每次左边出一个节点,如果该节点有左右节点,就将左右节点入队列,直到队列空为止
:param root:
:return:
'''
from collections import deque
if root == None:
return
queue = deque()
queue.append(root)
res = []
while queue:
node = queue.popleft()
res.append(node.val)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
2.二叉树的锯齿形层次遍历 leetcode103
3.二叉树自底向上层次遍历
4.判断一棵树是不是二叉完全树
5.找树左下角的值 leetcode153
思想：层次遍历找最后一层的第一个节点的值
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def findBottomLeftValue(self, root: TreeNode) -> int:
#层次遍历，找最后一层的第一个数
self.res = []
def levelOrder(root,level):
if not root:
return
if len(self.res) == level:#如果层数和res里面的长度相等，说明该层已经遍历完，或者是第一次遍历，就新建一个[]，用来放下一层的数据
self.res.append([])
self.res[-1].append(root.val)
if root.left:
levelOrder(root.left,level+1)
if root.right:
levelOrder(root.right,level+1)
if not root:
return
if not root.left and not root.right:
return root.val
levelOrder(root,0)
return self.res[-1][0]
六、给定二叉树前、中序遍历，构造二叉树
分析：
前序遍历序列第一个是根节点x
从中序遍历序列中找到根节点x
中序遍历中x的左边序列对应等长的前序遍历序列【左子树】
中序遍历中的x的右边序列对应等长的前序遍历序列【右子树】
class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def buildTree(preorder,inorder):
if preorder == []:
return None
val = preorder[0]
idx = inorder.index(val)
l_inorder = inorder[0:idx]
r_inorder = inorder[idx+1:]
l_preorder = preorder[1:1+len(l_inorder)]
r_preorder = preorder[1+len(l_inorder):]
root = TreeNode(val)
root.left = buildTree(l_preorder,l_inorder)
root.right = buildTree(r_preorder,r_inorder)
return root
七、给定二叉树中、后序遍历，构造二叉树
class TreeNode(object):
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def buildTree(inorder,postorder):
if postorder == []:
return None
val = postorder[-1]
idx = inorder.index(val)
l_inorder = inorder[0:idx]
r_inorder = inorder[idx+1:]
l_postorder = postorder[:len(l_inorder)]
r_postorder = postorder[len(l_inorder):-1]
root = TreeNode(val)
root.left = buildTree(l_inorder,l_postorder)
root.right = buildTree(r_inorder,r_postorder)
return root
