文章目录
110.平衡二叉树
思路-递归：
- 明确递归函数的参数和返回值
参数：当前传入节点。 返回值：以当前传入节点为根节点的树的高度。
那么如何标记左右子树是否差值大于1呢？
如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，还返回高度的话就没有意义了。
所以如果已经不是二叉平衡树了，可以返回-1 来标记已经不符合平衡树的规则了。
代码如下：
// -1 表示已经不是平衡二叉树了，否则返回值是以该节点为根节点树的高度
int getHeight(TreeNode* node)
- 明确终止条件
递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的树高度为0
代码如下：
if (node == NULL) {
return 0;
}
- 明确单层递归的逻辑
如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？当然是其左子树高度和其右子树高度的差值。
分别求出其左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。
代码：用-1标记是否为平衡树，且当左右子树为-1或者差值>1时，都返回-1
///递归-后序遍历获得高度
// 递归
///递归-后序遍历获得高度
class Solution {
public boolean isBalanced(TreeNode root) {
return get(root)==-1?false:true;
}
int get(TreeNode root){
//
if(root==null)return 0;
int l=get(root.left);
int r=get(root.right);
// 注意：左右子树应该分别判断一下是不是平衡树
if(Math.abs(l-r)>1||l==-1||r==-1){
return -1;
}else{
return Math.max(l,r)+1;
}
}
}
思路二-迭代
模拟栈依次判断每个结点是否满足高度差，使用层序遍历获得高度
lass Solution {//统一迭代法
public boolean isBalanced(TreeNode root) {
Stack<TreeNode> stack=new Stack<>();
if(root!=null){
stack.push(root);
}
while(!stack.isEmpty()){
TreeNode node = stack.peek();//中
if(node!=null){
node=stack.pop();
stack.push(node);
stack.push(null);
if(node.right!=null){//右
stack.push(node.right);
}
if(node.left!=null){//左
stack.push(node.left);
}
}else{
stack.pop();
node=stack.pop();
if(Math.abs(getheight(node.left)-getheight(node.right))>1){
return false;
}
}
}
return true;
}
// 层序遍历获得高度
public int getheight(TreeNode root) {
if (root == null) {
return 0;
}
Deque<TreeNode> deque = new LinkedList<>();
deque.offer(root);
int depth = 0;
while (!deque.isEmpty()) {
int size = deque.size();
depth++;
for (int i = 0; i < size; i++) {
TreeNode poll = deque.poll();
if (poll.left != null) {
deque.offer(poll.left);
}
if (poll.right != null) {
deque.offer(poll.right);
}
}
}
return depth;
}
}
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.左叶子之和
这道题目要求左叶子之和，其实是比较绕的，因为不能判断本节点是不是左叶子节点。
此时就要通过节点的父节点来判断其左孩子是不是左叶子了。
平时我们解二叉树的题目时，已经习惯了通过节点的左右孩子判断本节点的属性，而本题我们要通过节点的父节点判断本节点的属性。
思路-递归
判断当前节点是不是左叶子是无法判断的，必须要通过节点的父节点来判断其左孩子是不是左叶子。
如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子，判断代码如下：
if (node->left != NULL && node->left->left == NULL && node->left->right == NULL) {
左叶子节点处理逻辑
}
递归的遍历顺序为后序遍历（左右中），是因为要通过递归函数的返回值来累加求取左叶子数值之和。
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;
}
}
思路：统一迭代
在节点处判断逻辑
/**
* 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 int sumOfLeftLeaves(TreeNode root) {
// List<Integer> result = new LinkedList<>();
Stack<TreeNode> st = new Stack<>();
if (root != null) st.push(root);
int res=0;
while (!st.empty()) {
TreeNode node = st.peek();
if (node != null) {
st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
st.push(node); // 添加中节点
st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
if (node.right!=null) st.push(node.right); // 添加右节点（空节点不入栈）
if (node.left!=null) st.push(node.left); // 添加左节点（空节点不入栈）
} else { // 只有遇到空节点的时候，才将下一个节点放进结果集
st.pop(); // 将空节点弹出
node = st.peek(); // 重新取出栈中元素
st.pop();
if(node.left!=null&&node.left.left==null&&node.left.right==null){
res+=node.left.val;
}
// result.add(node.val); // 加入到结果集
}
}
return res;
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
