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;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
