110. 平衡二叉树(优先掌握递归)
再一次涉及到,什么是高度,什么是深度,可以巩固一下。题目链接/文章讲解/视频讲解:代码随想录
重点:
1. 深度:指从根节点到该节点的最长简单路径边的条数。用前序遍历求深度
2. 高度:指从该节点到叶子节点的最长简单路径边的条数。用后序遍历求高度
思路:
递归三部曲:
1. 明确递归函数的参数和返回值:
参数:当前传入节点。 返回值:以当前传入节点为根节点的树的高度。
2. 明确终止条件:
递归的过程中依然是遇到空节点了为终止,返回0,表示当前节点为根节点的树高度为0
3. 明确单层递归的逻辑:
分别求出其左右子树的高度,然后如果差值小于等于1,则返回当前二叉树的高度,否则返回-1,表示已经不是二叉平衡树了。
public static boolean isBalanced(TreeNode root) {
int result = getHeight(root);
if (result == -1) {
return false;
} else {
return true;
}
}
public static int getHeight(TreeNode cur) {
if (cur == null) {
return 0;
}
// 左
// 如果发现左子树已经不是平衡二叉树的,直接接着返回-1
int leftHeight = getHeight(cur.left);
if (leftHeight == -1) {
return -1;
}
// 右
// 如果发现右子树已经不是平衡二叉树的,直接接着返回-1
int rightHeight = getHeight(cur.right);
if (rightHeight == -1) {
return -1;
}
// 中
// 判断当前节点是否为平衡二叉树
if (Math.abs(leftHeight - rightHeight) > 1) {
return -1;
}
return 1 + Math.max(leftHeight, rightHeight);
}
257. 二叉树的所有路径(优先掌握递归)
这是大家第一次接触到回溯的过程, 我在视频里重点讲解了 本题为什么要有回溯,已经回溯的过程。如果对回溯 似懂非懂,没关系, 可以先有个印象。
题目链接/文章讲解/视频讲解: 代码随想录重点:1. 这道题目要求从根节点到叶子的路径,所以需要前序遍历,这样才方便让父节点指向孩子节点,找到对应的路径。2. 递归 + 回溯思路:
递归加回溯法:
1. 参数及返回值:
void traversal(TreeNode root, List<Integer> paths, List<String> res)
2. 递归的终止条件:本题要找到叶子节点,就开始结束的处理逻辑了(把路径放进result里)。if (root.left == null && root.right == null) {}
3. 单层递归的逻辑:注意递归函数的地址传递和值传递的区别!!!因为是前序遍历,需要先处理中间节点,中间节点就是我们要记录路径上的节点,先放进path中。在这里递归的时候,如果为空就不进行下一层递归了。所以递归前要加上判断语句,下面要递归的节点是否为空。此时还没完,递归完,要做回溯啊,因为path 不能一直加入节点,它还要删节点,然后才能加入新的节点。回溯和递归是一一对应的,有一个递归,就要有一个回溯。if (root.left != null) { // 左 traversal(root.left, paths, res); paths.remove(paths.size() - 1);// 回溯 } if (root.right != null) { // 右 traversal(root.right, paths, res); paths.remove(paths.size() - 1);// 回溯 }
迭代法:1. 用栈来模拟递归,先进后出2. 节点和到当前节点的路径同时入栈及出栈
public List<String> binaryTreePaths(TreeNode root) {
// 记录最终结果
List<String> result = new ArrayList<>();
if (root == null) {
return result;
}
// 用来记录一条路径,回溯时需删除某些节点
List<Integer> paths = new ArrayList<>();
traversal(root, paths, result);
return result;
}
// 地址传递
private void traversal(TreeNode cur, List<Integer> paths, List<String> result) {
// 中
paths.add(cur.val);
// 终止条件
// 遇到叶子节点了,也就是找到一条路径
if (cur.left == null && cur.right == null) {
// 组合好字符串放入到result
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < paths.size() - 1; i++) {
stringBuilder.append(paths.get(i));
stringBuilder.append("->");
}
stringBuilder.append(paths.get(paths.size() - 1));
result.add(stringBuilder.toString());
return;
}
// 左
if (cur.left != null) {
traversal(cur.left, paths, result);
// 回溯,处理完一个路径上的节点就需要弹出
paths.remove(paths.size() - 1);
}
// 右
if (cur.right != null) {
traversal(cur.right, paths, result);
// 回溯,处理完一个路径上的节点就需要弹出
paths.remove(paths.size() - 1);
}
}
List<String> result = new ArrayList<>();
public List<String> binaryTreePaths(TreeNode root) {
if (root == null) {
return result;
}
traversal(root, "");
return result;
}
// 值传递
private void traversal(TreeNode cur, String path) {
// 终止条件
// 遇到叶子节点
if (cur.left == null && cur.right == null) {
// 中
StringBuilder stringBuilder = new StringBuilder(path);
stringBuilder.append(cur.val);
result.add(stringBuilder.toString());
return;
}
// 左
if (cur.left != null) {
StringBuilder stringBuilder = new StringBuilder(path);
stringBuilder.append(cur.val);
stringBuilder.append("->");
// 这里其实就有回溯
// 因为String path每次都是赋值拷贝,不是地址拷贝
traversal(cur.left, stringBuilder.toString());
}
// 右
if (cur.right != null) {
StringBuilder stringBuilder = new StringBuilder(path);
stringBuilder.append(cur.val);
stringBuilder.append("->");
// 这里其实就有回溯
// 因为String path每次都是赋值拷贝,不是地址拷贝
traversal(cur.right, stringBuilder.toString());
}
}
public List<String> binaryTreePaths(TreeNode root) {
List<String> result = new ArrayList<>();
if (root == null)
return result;
Deque<TreeNode> nodeStack = new LinkedList<>();
Deque<String> pathStack = new LinkedList<>();
nodeStack.offerLast(root);
pathStack.offerLast(String.valueOf(root.val));
while (!nodeStack.isEmpty()) {
// 中
// 节点和到该节点的路径同时出栈
TreeNode cur = nodeStack.removeLast();
String path = pathStack.removeLast();
// 遇到叶子节点
if (cur.left == null && cur.right == null) {
result.add(path);
}
// 右
if (cur.right != null) {
nodeStack.offerLast(cur.right);
// 把到当前右节点的路径推入栈
pathStack.offerLast(path + "->" + cur.right.val);
}
// 左
if (cur.left != null) {
nodeStack.offerLast(cur.left);
// 把到当前左节点的路径推入栈
pathStack.offerLast(path + "->" + cur.left.val);
}
}
return result;
}
404. 左叶子之和(优先掌握递归)
其实本题有点文字游戏,搞清楚什么是左叶子,剩下的就是二叉树的基本操作。题目链接/文章讲解/视频讲解:代码随想录
重点:
1. 判断当前节点是不是左叶子是无法判断的,必须要通过节点的父节点来判断其左孩子是不是左叶子。
思路:
递归法:
1. 确定参数及返回值public int sumOfLeftLeaves(TreeNode root)
2. 确定终止条件
如果遍历到空节点,那么左叶子值一定是0。
如果当前遍历的节点是叶子节点,那其左叶子也必定是0,那么终止条件为:
if (root == null) return 0; if (root.left == null && root.right == null) return 0;
3. 确定单层递归的逻辑
当遇到左叶子节点的时候,记录数值,然后通过递归求取左子树左叶子之和,和 右子树左叶子之和,相加便是整个树的左叶子之和。
迭代法:
1. 前/中/后序遍历,用栈来模拟递归。
2. 在遍历过程中,发现当前节点的左节点为叶子节点就说明为左叶子
public int sumOfLeftLeaves(TreeNode root) {
// 终止条件
if (root == null) {
return 0;
}
if (root.left == null && root.right == null) {
return 0;
}
// 左
int leftValue = sumOfLeftLeaves(root.left);
// 左子树就是左叶子
if (root.left != null && root.left.left == null && root.left.right == null) {
leftValue = root.left.val;
}
// 右
int rightValue = sumOfLeftLeaves(root.right);
// 中
int sum = leftValue + rightValue;
return sum;
}
// 前序遍历
public int sumOfLeftLeaves(TreeNode root) {
int result = 0;
if (root == null) {
return result;
}
Deque<TreeNode> stack = new LinkedList<>();
stack.offerLast(root);
while (!stack.isEmpty()) {
TreeNode cur = stack.removeLast();
// 中
// 当前节点的左节点为左叶子,加入result
if (cur.left != null && cur.left.left == null && cur.left.right == null) {
result += cur.left.val;
}
// 右
if (cur.right != null) {
stack.offerLast(cur.right);
}
// 左
if (cur.left != null) {
stack.offerLast(cur.left);
}
}
return result;
}