代码随想录第十七天| ● 110.平衡二叉树 ● 257. 二叉树的所有路径 ● 404.左叶子之和
文章目录
- 110.平衡二叉树
-
- 思路-递归：
-
- 代码：
- 思路二-迭代
- 257. 二叉树的所有路径
-
-
- 思路一：普通递归
- 思路二：递归优化
- 思路三：迭代法（没细看）
-
- 404.左叶子之和
-
- 思路-递归
110.平衡二叉树
思路-递归：
- 明确递归函数的参数和返回值
参数：当前传入节点。 返回值：以当前传入节点为根节点的树的高度。
那么如何标记左右子树是否差值大于1呢？
如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，还返回高度的话就没有意义了。
所以如果已经不是二叉平衡树了，可以返回-1 来标记已经不符合平衡树的规则了。
代码如下：
// -1 表示已经不是平衡二叉树了，否则返回值是以该节点为根节点树的高度
int getHeight(TreeNode* node)
- 明确终止条件
递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的树高度为0
代码如下：
if (node == NULL) {
return 0;
}
- 明确单层递归的逻辑
如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？当然是其左子树高度和其右子树高度的差值。
分别求出其左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。
代码：
///递归-后序遍历获得高度
class Solution {
public boolean isBalanced(TreeNode root) {
return getheight(root)==-1?false:true;
}
public int getheight(TreeNode root){//返回高度差
if(root==null)return 0;
int left=0,right=0;
left=getheight(root.left);
if(left==-1){
return -1;
}
right=getheight(root.right);
if(right==-1){
return -1;
}
return Math.abs(left-right)>1?-1:Math.max(left,right)+1;
}
}
思路二-迭代
depth代表当前迭代节点的高度，往下走就加1，向上回溯就-1 ，result代表最大深度，每次迭代跟depth比较然后更新
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public boolean isBalanced(TreeNode root) {
Stack<TreeNode> stack=new Stack<>();
if(root!=null){
stack.push(root);
}
while(!stack.isEmpty()){
TreeNode node = stack.pop();//中
if(Math.abs(getheight(node.left)-getheight(node.right))>1){
return false;
}
if(node.right!=null){//右
stack.push(node.right);
}
if(node.left!=null){//中
stack.push(node.left);
}
}
return true;
}
public int getheight(TreeNode root){//返回高度
Stack<TreeNode> stack=new Stack<>();
if(root!=null){
stack.push(root);
}
int deep=0;
int result=0;
while(!stack.isEmpty()){
TreeNode node = stack.peek();
if(node!=null){
stack.pop();
stack.push(node);
stack.push(null);//中
deep++;
if(node.right!=null)stack.push(node.right);//右
if(node.left!=null)stack.push(node.left);//左
}else{
stack.pop();
node=stack.pop();
deep--;
}
result=result>deep?result:deep;
}
return result;
}
}
257. 二叉树的所有路径
思路一：普通递归
path储存路径节点，res储存所有路径
因为每次递归会修改path数组list，所以递归时要进行回溯
class Solution {
public List<String> binaryTreePaths(TreeNode root) {
List<String> res = new ArrayList<>();
if(root==null){
return res;
}
List<Integer> path = new ArrayList<>();
traversal(root,path,res);
return res;
}
private void traversal(TreeNode node,List<Integer>paths,List<String> res){
// 中，中为什么写在这里，因为最后一个节点也要加入到path中
paths.add(node.val);
// 找到叶子结点了，储存路径
// 中
if(node.left==null&&node.right==null){
// StringBuilder用来拼接字符串，速度更快
StringBuilder sb = new StringBuilder();
for (int i = 0; i < paths.size() - 1; i++) {
sb.append(paths.get(i)).append("->");
}// 把path储存的数据逐一链接为路径
// 记录做后一个节点
sb.append(paths.get(paths.size()-1));
// 收集一个路径
res.add(sb.toString());
return;
}
// 左
if(node.left!=null){
// 有递归就有回溯
traversal(node.left,paths,res);// 递归
paths.remove(paths.size() - 1);// 回溯
}
if(node.right!=null){
// 有递归就有回溯
traversal(node.right,paths,res);// 递归
paths.remove(paths.size() - 1);// 回溯
}
}
}
思路二：递归优化
递归时把 tmp作为函数参数就是可以的，因为并没有改变String tmp的数值，执行完递归函数之后，tmp依然是之前的计算的数值（相当于回溯了）
class Solution {
List<String> res=new ArrayList<>();
public List<String> binaryTreePaths(TreeNode root) {
deel(root,"");
return res;
}
public void deal(TreeNode node,String s){
if(node == null)return;
if(node.left==null&&node.right==null){
result.add(new StringBuilder(s).append(node.val).toString());
return;
}
String tmp=new StringBuilder(s).append(node.val).append("->").toString();
deal(node.left,tmp);
deal(node.right,tmp);
}
}
思路三：迭代法（没细看）
Java 可以直接定义一个成员变量为object的栈，这个栈可以放 TreeNode，可以放 String，这样就不需要搞两个栈，都放在一个栈里即可。
力扣题解+图解
class Solution {
/**
* 迭代法
*/
public List<String> binaryTreePaths(TreeNode root) {
List<String> result = new ArrayList<>();
if (root == null)
return result;
Stack<Object> stack = new Stack<>();
// 节点和路径同时入栈
stack.push(root);
stack.push(root.val + "");
while (!stack.isEmpty()) {
// 节点和路径同时出栈
String path = (String) stack.pop();
TreeNode node = (TreeNode) stack.pop();
// 若找到叶子节点
if (node.left == null && node.right == null) {
result.add(path);
}
//右子节点不为空
if (node.right != null) {
stack.push(node.right);
stack.push(path + "->" + node.right.val);
}
//左子节点不为空
if (node.left != null) {
stack.push(node.left);
stack.push(path + "->" + node.left.val);
}
}
return result;
}
}
404.左叶子之和
这道题目要求左叶子之和，其实是比较绕的，因为不能判断本节点是不是左叶子节点。
此时就要通过节点的父节点来判断其左孩子是不是左叶子了。
平时我们解二叉树的题目时，已经习惯了通过节点的左右孩子判断本节点的属性，而本题我们要通过节点的父节点判断本节点的属性。
思路-递归
class Solution {
public int sumOfLeftLeaves(TreeNode root) {
if (root == null) return 0;
int midValue = 0;
// sumOfLeftLeaves(root.left)
if(root.left!=null&&root.left.right==null&&root.left.left==null){
midValue=root.left.val;
}
int leftValue = sumOfLeftLeaves(root.left); // 左
int rightValue = sumOfLeftLeaves(root.right); // 右
int sum = midValue + leftValue + rightValue; // 中
return sum;
}
}