目录
144、二叉树的前序遍历 - 力扣
思路：采用递归思想，先判断是否为空树，若不是空树，递归访问其左子树，然后递归访问其右子树，最后返回 list 集合元素即为所求的二叉树的前序遍历。
class Solution {
List<Integer> ret = new ArrayList<>();
/**
* 传入一个二叉树的根节点root，就能返回其前序遍历的结果集
* 此处访问节点操作是将节点值存储在list集合中
* 递归
* @param root
* @return
*/
public List<Integer> preorderTraversal(TreeNode root) {
if (root == null){
return ret;
}
ret.add(root.val);
//递归访问左子树
preorderTraversal(root.left);
//递归访问右子树
preorderTraversal(root.right);
return ret;
}
//借助栈来实现前序遍历
// public List<Integer> preorderTraversal(TreeNode root) {
// List<Integer> ret = new ArrayList<>();
// if (root == null) {
// return ret;
// }
// Deque<TreeNode> stack = new ArrayDeque<>();
// stack.push(root);
// while (!stack.isEmpty()){
// TreeNode cur =stack.pop();
// //先访问根节点
// ret.add(cur.val);
// //将右孩子压入栈
// if (cur.right != null) {
// stack.push(cur.right);
// }
// // 再压入左孩子
// if (cur.left != null) {
// stack.push(cur.left);
// }
// }
// return ret;
// }
}100、相同的树 - 力扣
思路：首先判断其边界条件，两棵树都为空，若有一个树为空的情况，剩下的就可以采用递归思想，判断p的值是否等于q的值，再依次判断p的左孩子是否等于q的左孩子，p的右孩子是否等于q的右孩子。
public class Num100_SameTree {
//传入两棵树 p和q ,判断p和q是否是相同的树
public boolean isSameTree(TreeNode p, TreeNode q) {
//边界条件
if (p == null && q == null){
return true;
}
if (p == null || q == null){
return false;
}
return p.val == q.val && isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
}
}101、对称二叉树 - 力扣
思路：首先判断边界条件，然后判断left和right镜像相等
//对称二叉树
public class Num101_SymmetricTree {
public boolean isSymmetric(TreeNode root){
return check(root,root);
}
public boolean check(TreeNode p,TreeNode q){
if (p == null && q == null){
return true;
}
if (p == null || q == null){
return false;
}
return p.val == q.val && check(p.left,q.right) && check(p.right,q.left);
}
// public boolean isSymmetric(TreeNode root) {
// // 边界
// if (root == null) {
// return true;
// }
// return isMirror(root.left,root.right);
// }
// 判断left和right这两棵树是否是一个镜像相等
// private boolean isMirror(TreeNode left, TreeNode right) {
// if (left == null && right == null) {
// return true;
// }
// if (left == null || right == null) {
// return false;
// }
// if (left.val != right.val) {
// return false;
// }
// // left的左树要和right的右树镜像相等 && left的右树要和right的左树镜像相等
// return isMirror(left.left,right.right) && isSameTree(left.right,right.left);
// }
}110、平衡二叉树 - 力扣
思路：判断一棵树root是否是一颗平衡树 => 以root为根节点的二叉树左右子树高度差<= 1
&&左树也是平衡树&&右树也是平衡树
我们发现，在判断平衡树的过程中，若干个节点的高度可能会被重复计算多次，造成了递
归重复执行。越靠下的节点，重复的几率越高。
/**
* 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) {
//边界
if (root == null){
return true;
}
//判断当前以root为根节点的树是否满足条件
int left = height(root.left);
int right = height(root.right);
//求绝对值 abs
int abs = Math.abs(left - right);
if (abs > 1){
return false;
}
//继续递归判断左树是否满足平衡 并且 右树是否满足平衡
return isBalanced(root.left) && isBalanced(root.right);
}
//递归求树的高度
private int height(TreeNode root) {
if (root == null){
return 0;
}
return 1 + Math.max(height(root.left),height(root.right));
}
}958、二叉树的完全性检验 - 力扣
思路：最初默认为第一种状态，当层序遍历发现其无右子树或者左右子树都无时，切换状态，第二种状态下遍历的每一个节点都必须保证时叶子节点，否则就不是完全二叉树。
package bin_tree.leetcode;
import java.util.*;
//判断完全二叉树
public class Num958_IsCompleteTree {
public boolean isCompleteTree(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<>();
//先将根节点入队
queue.offer(root);
//判断当前所处的状态
//最开始默认处于第一种状态
boolean isSecondStep = false;
while (!queue.isEmpty()) {
//将根节点出队
TreeNode cur = queue.poll();
if (!isSecondStep) {
//此时处于第一种状态
if (cur.left != null && cur.right != null) {
//若左右子树都不为空，将其入队
queue.offer(cur.left);
queue.offer(cur.right);
}else if (cur.left != null) {
//只有左子树没有右子树，切换状态
isSecondStep = true;
//左树出队
queue.offer(cur.left);
} else if (cur.right != null) {
//只有右子树没有左子树，不存在
return false;
}else {
//左右子树都为空 -》 第一个叶子节点，切换状态
isSecondStep = true;
}
}else {
//此时处于第二种状态，所有节点必须是叶子节点
//若有一个节点有子树就可以证明不是完全二叉树
if (cur.left != null || cur.right != null) {
return false;
}
}
}
return true;
}
}
662、二叉树的最大宽度 - 力扣
思路：本题采用一种巧妙地办法，即为节点编号，借助完全二叉树的节点编号，在实际操作过程中，层序遍历时存储每个节点和它的编号，每一层遍历结束，取出最左侧的节点标号L和最右侧的节点编号R，该层的宽度就是R-L+1；若根节点从1开始编号，父节点的编号为K，左孩子编号为2K，右孩子编号为2K+1。
class Solution {
public int widthOfBinaryTree(TreeNode root) {
if (root == null) {
return 0;
}
int maxWidth = 0;
Queue<NodeWithNum> queue = new LinkedList<>();
queue.offer(new NodeWithNum(root,1));
while (!queue.isEmpty()) {
int levelWidth = 0;
//当前队列中该层的元素个数
int size = queue.size();
//最左侧的节点编号
int L = 0;
//最右侧的节点编号
int R = 0;
for (int i = 0; i < size; i++) {
//将根节点出队
NodeWithNum cur = queue.poll();
if (i == 0) {
//最左侧的节点
L = cur.num;
}if (i == size-1) {
//最右侧的节点
R = cur.num;
}
if (cur.node.left != null) {
queue.offer(new NodeWithNum(cur.node.left, cur.num * 2));
}
if (cur.node.right != null) {
queue.offer(new NodeWithNum(cur.node.right, cur.num * 2 + 1));
}
}
levelWidth = R - L + 1;
maxWidth = Math.max(levelWidth,maxWidth);
}
return maxWidth;
}
// 此时我们在层序遍历的过程中会存储每个出现的节点和他的编号，我就创建一个新的类
// 我们就将TreeNode二次包装，新增一个该节点的值
private class NodeWithNum {
// 具体每个二叉树的节点
TreeNode node;
// 该节点的编号
int num;
public NodeWithNum(TreeNode node, int num) {
this.node = node;
this.num = num;
}
}
}本小节完^_^
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
