1 树的定义
树是递归定义的,所以和树相关的很多操作,用递归更容易实现。
2 树的遍历
采用python实现代码的原因是因为python语言本身较为简单,可以把时间和精力集中于思考真正的问题。
树的前序遍历
此题是leetcode的589题
前序遍历 前指的是根节点最先遍历。 满足同一父节点的孩子节点,左边的节点总是比右边的节点先遍历。 采用的数据结构为栈。 可以看到,在程序执行过程中,根节点的值会最先进入output。在每一个节点的子节点的进栈过程中,子节点需要逆序进栈,这样pop的时候就是顺序的,即满足同一父节点的孩子节点,左边的节点总是比右边的节点先遍历。
class Node(object):
def __init__(self, val, children):
self.val = val
self.children = children
class Solution(object):
def preorder(self, root):
if root is None:
return []
stack, output = [root], []
while stack:
root = stack.pop()
output.append(root.val)
stack.extend(root.children[::-1])
return output
树的后序遍历
此题是leetcode的590题
后序遍历 后指的是根节点最后遍历。 满足同一父节点的孩子节点,左边的节点总是比右边的节点先遍历。 采用的数据结构为栈。
可以看到在程序执行过程中,根节点的值会最先进入output, 那么为了让这个值最后输出,可以将output在返回时逆序。
那么在进栈的每一层的遍历过程中,子节点需要顺序进栈,这样pop的时候就是逆序的,output返回逆序后又会变成正的,即满足同一父节点的孩子节点,左边的节点总是比右边的节点先遍历。
class Node(object):
def __init__(self, val, children):
self.val = val
self.children = children
class Solution(object):
def postorder(self, root):
if root is None:
return []
stack, output = [root], []
while stack:
root = stack.pop()
output.append(root.val)
stack.extend(root.children)
return output[::-1]
递归实现
https://pintia.cn/problem-sets/15/problems/732
2.1.1 前序遍历
void PreorderTraversal( BinTree BT ){
if (BT) {
printf(" %c",BT->Data);
PreorderTraversal(BT->Left);
PreorderTraversal(BT->Right);
}
}
2.1.2 中序遍历
void InorderTraversal( BinTree BT ){
if (BT) {
InorderTraversal(BT->Left);
printf(" %c",BT->Data);
InorderTraversal(BT->Right);
}
}
2.1.3 后序遍历
void PostorderTraversal( BinTree BT ){
if (BT) {
PostorderTraversal(BT->Left);
PostorderTraversal(BT->Right);
printf(" %c",BT->Data);
}
}
2.1.4 层序遍历
void LevelorderTraversal( BinTree BT ){
BinTree str[100], t;
int rear = -1,front = -1;
if (!BT) {
return;
}
rear++;
str[rear] = BT;
while (rear != front) {
front++;
t = str[front];
printf(" %c",t->Data);
if (t->Left) {
rear++;
str[rear] = t->Left;
}
if (t->Right) {
rear++;
str[rear] = t->Right;
}
}
}
2.2 迭代实现
3 重建二叉树
3.1 已知前序遍历和中序遍历
此题是牛客网剑指offer第4题
二叉树的问题用递归都会简单些。前序遍历的第一个元素就是根节点。根据该节点在中序遍历中的位置,可以将前序遍历和中序遍历分为左子树和右子树。如此,递归即可求解。
class Solution:
# 返回构造的TreeNode根节点
def reConstructBinaryTree(self, pre, tin):
# write code here
if len(pre) == 0:
return None
else:
ans = TreeNode(pre[0])
idx = tin.index(pre[0])
ans.left = self.reConstructBinaryTree(pre[1:idx+1], tin[:idx])
ans.right = self.reConstructBinaryTree(pre[idx+1:], tin[idx+1:])
return ans
3.2 已知后序遍历和中序遍历
4 树的相关练习题
4.1 基础练习
4.1.1 牛客网树的子结构
class Solution:
#判断 单个root的子树的程序
def isSubtree(self, root1, root2):
#如果2遍历完说明 匹配成功
if root2 == None:
return True
#如果1便利完说明,2还没便利完,匹配不成功
if root1 == None:
return False
#如果这对根节点的值相等,进行相应的递归遍历这对节点的 左右节点是否匹配
if root1.val == root2.val:
return self.isSubtree(root1.left,root2.left) and self.isSubtree(root1.right,root2.right)
#总程序
def HasSubtree(self, pRoot1, pRoot2):
# write code here
#特殊情况 需判断
if pRoot1 == None or pRoot2 == None:
return False
#进行递归判断和遍历,判断1此时是否有2的子树,或1的左子树中是否存在与2相同的的子树,或1的右子树是否存在与2相同的子树
return self.isSubtree(pRoot1,pRoot2) or self.HasSubtree(pRoot1.left,pRoot2) or self.HasSubtree(pRoot1.right,pRoot2)
4.1.2 牛客网二叉树的镜像
class Solution:
# 返回镜像树的根节点
def Mirror(self, root):
# write code here
# 基准条件
if root == None:
return None
# 将左右子树互换位置
t = root.left
root.left = root.right
root.right = t
# 递归每一个节点 将左右子树互换位置
self.Mirror(root.left)
self.Mirror(root.right)
return root
4.1.3 牛客网从上往下打印二叉树
class Solution:
# 返回从上到下每个节点值列表,例:[1,2,3]
def PrintFromTopToBottom(self, root):
# write code here
queue = []
#
if not root:
return []
result = []
queue.append(root)
while len(queue) > 0:
currentRoot = queue.pop(0)
result.append(currentRoot.val)
if currentRoot.left:
queue.append(currentRoot.left)
if currentRoot.right:
queue.append(currentRoot.right)
return result
4.1.4 二叉树的后序遍历序列
知识点回顾:
二叉搜索树(Binary Search Tree,BST)又称二叉排序树、二叉查找树。二叉排序树或者是一棵空树,或者是具有下列性质的二叉树:
- 若左子树不空,则左子树上所有结点的值均小于或等于它的根结点的值;
- 若右子树不空,则右子树上所有结点的值均大于或等于它的根结点的值;
- 左、右子树也分别为二叉排序树;
特点:左子树结点的值都小于根节点的值,右子树结点的值都大于根节点的值
后序遍历:先后序遍历左子树,再后序遍历右子树,最后访问根节点
思路:
后序遍历得到的序列,最后一个数是树的根节点的值 ,序列中最后一个数前面的数可以分为两部分:一部分是左子树节点的值,它们都比根节点的值小;第二部分是右子树节点的值,它们都比根节点的值要大。用递归的方法分别判断这两部分是否满足前面说得条件
# -*- coding:utf-8 -*-
# -*- coding:utf-8 -*-
class Solution:
# 返回镜像树的根节点
def VerifySquenceOfBST(self, sequence):
if len(sequence) == 0:
return False
root = sequence[-1]
# 左子树所有节点的值应该都小于root
for i in range(len(sequence)):
if sequence[i] > root:
break
# 右子树所有节点的值应该都大于root
for j in range(i, len(sequence)):
if sequence[j] < root:
return False
# 进入所有子树进行递归判断
left = True
if i > 0:
left = self.VerifySquenceOfBST(sequence[0:i])
right = True
if i < len(sequence)-1 and left:
right = self.VerifySquenceOfBST(sequence[i:-1])
return right
4.1.5 二叉树中和为某一值的路径
思路:
可以按照深度优先遍历(DFS)来处理。创建一个空列表用来存放最终结果。从根节点开始,判断该节点的值与给定数值是否相等以及左、右子树是否为空。如果是,就把对应的值返回;如果不是,我们就分别对根节点的左子树、右子树进行递归。
# -*- coding:utf-8 -*-
class Solution:
def FindPath(self, root, expectNumber):
rst = []
if not root:
return []
if not root.left and not root.right and root.val == expectNumber:
return [[root.val]]
else:
left = self.FindPath(root.left, expectNumber - root.val)
right = self.FindPath(root.right, expectNumber - root.val)
for item in left + right:
rst.append([root.val] + item)
return rst