144. 二叉树的前序遍历
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
提示：
树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100
示例 1：
输入：root = [1,null,2,3]
输出：[1,2,3]
示例 2：
输入：root = []
输出：[]
示例 3：
输入：root = [1]
输出：[1]
示例 4：
输入：root = [1,2]
输出：[1,2]
示例 5：
输入：root = [1,null,2]
输出：[1,2]
解析过程：
二叉树的前序遍历算法顺序：根-左-右
采用递归算法。先访问 root 节点，然后将 root 节点的值加入存储答案的集合中，再递归调用 方法来遍历 root 节点的左子树，以及root 节点的右子树，直到碰到空节点，递归终止。
class Solution {
public List preorderTraversal(TreeNode root) {
//DFS
List node =new ArrayList<>();
PreOrder(root,node);
return node;
}
public void PreOrder(TreeNode root,List node){
if(root == null){
return;
}
node.add(root.val);
PreOrder(root.left,node);
PreOrder(root.right,node);
}
}
调试：
import java.util.List;
public class Main {
public static void main(String[] args) {
System.out.println("----递归------");
System.out.println("前序：");
TreeNode treeNode = new TreeNode(1, null, new TreeNode(2, new TreeNode(3, null, null), null));
List list = new Leetcode144().preorderTraversal(treeNode);
for (int i = 0; i
结果：
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：36.8 MB, 在所有 Java 提交中击败了22.27%的用户
通过测试用例：69 / 69
94. 二叉树的中序遍历
给定一个二叉树的根节点 root ，返回它的 中序 遍历。
提示：
树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100
示例 1：
输入：root = [1,null,2,3]
输出：[1,3,2]
示例 2：
输入：root = []
输出：[]
示例 3：
输入：root = [1]
输出：[1]
示例 4：
输入：root = [1,2]
输出：[2,1]
示例 5：
输入：root = [1,null,2]
输出：[1,2]
解析过程：
二叉树的中序遍历算法顺序：左-根-右
采用递归算法。先递归调用方法遍历root节点的左子树，然后将root节点的值加入存储答案的集合中，再递归调用方法遍历root节点的右子树，直到碰到空节点，递归终止。
class Solution {
public List inorderTraversal(TreeNode root) {
//中序遍历：左-根-右
List node=new ArrayList<>();
InOrder(root,node);
return node;
}
public void InOrder(TreeNode root,Listnode){
if(root == null){
return;
}
InOrder(root.left,node);
node.add(root.val);
InOrder(root.right,node);
}
}
结果：
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：36.7 MB, 在所有 Java 提交中击败了53.21%的用户
通过测试用例：68 / 68
145. 二叉树的后序遍历
给定一个二叉树，返回它的 后序 遍历。
示例:
输入: [1,null,2,3]
1
2
/
3
输出: [3,2,1]
解析过程：
二叉树的后序遍历算法顺序：左-右-根
采用递归算法。先递归调用方法遍历root节点的左子树，然后递归调用方法遍历root节点的右子树，最后将root节点的值加入存储答案的集合中，直到碰到空节点，递归终止。
class Solution {
public List postorderTraversal(TreeNode root) {
//后序遍历：左-右-根
List node=new ArrayList<>();
PostOrder(root,node);
return node;
}
public void PostOrder(TreeNode root,Listnode){
if(root == null){
return;
}
PostOrder(root.left,node);
PostOrder(root.right,node);
node.add(root.val);
}
}
结果：
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：36.6 MB, 在所有 Java 提交中击败了68.43%的用户
通过测试用例：68 / 68
102. 二叉树的层序遍历
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
示例：
二叉树：[3,9,20,null,null,15,7],
3
/
9 20
/
15 7
返回其层序遍历结果：
[
[3],
[9,20],
[15,7]
]
解析过程：
class Solution {
public List> levelOrder(TreeNode root) {
//层次遍历，类似于BFS，需要设置一个队列
Deque queue=new ArrayDeque<>();
//存储层序遍历的结果
List> list=new ArrayList<>();
//如果节点不为空，则加入队列
if(root !=null){
queue.add(root);
}
while(!queue.isEmpty()){
int len=queue.size();
List level=new ArrayList<>();
for(int i=0;i
结果：
执行用时：1 ms, 在所有 Java 提交中击败了90.91%的用户
内存消耗：38.8 MB, 在所有 Java 提交中击败了17.52%的用户
通过测试用例：34 / 34
104. 二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/
9 20
/
15 7
返回它的最大深度 3 。
解析过程：
class Solution {
public int maxDepth(TreeNode root) {
//DFS
//分别记录左子树和右子树的高度，最后两者中最大的数+1就是最大深度
if(root == null){
return 0;
}else{
int leftHeight=maxDepth(root.left);
int rightHeight=maxDepth(root.right);
return Math.max(leftHeight,rightHeight)+1;
}
}
}
结果：
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：38.6 MB, 在所有 Java 提交中击败了5.18%的用户
通过测试用例：39 / 39
101. 对称二叉树
给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/
2 2
/ /
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/
2 2
3 3
解析过程：
class Solution {
public boolean isSymmetric(TreeNode root) {
//迭代
return Symmetry(root,root);
}
public boolean Symmetry(TreeNode n1,TreeNode n2){
//设置一个队列，每次将左子树的左节点和右子树的右节点，以及左子树的右节点和右子树的左节点加入队列
Queue queue=new linkedList<>();
queue.offer(n1);
queue.offer(n2);
while(! queue.isEmpty()){
n1=queue.poll();
n2=queue.poll();
if(n1==null && n2 ==null ){
continue;
}
if((n1 ==null || n2==null)||(n1.val != n2.val)){
return false;
}
queue.offer(n1.left);
queue.offer(n2.right);
queue.offer(n1.right);
queue.offer(n2.left);
}
return true;
}
}
-------------------------------------------------
class Solution {
public boolean isSymmetric(TreeNode root) {
//递归
return Symmetry(root,root);
}
public boolean Symmetry(TreeNode n1,TreeNode n2){
if(n1 ==null && n2==null){
return true;
}
if((n1==null || n2==null)|| (n1.val !=n2.val)){
return false;
}
return Symmetry(n1.left,n2.right)&&Symmetry(n1.right,n2.left);
}
}
结果：
执行用时：1 ms, 在所有 Java 提交中击败了21.66%的用户
内存消耗：37.7 MB, 在所有 Java 提交中击败了13.74%的用户
通过测试用例：197 / 197
226. 翻转二叉树
翻转一棵二叉树。
示例：
输入：
4
/
2 7
/ /
1 3 6 9
输出：
4
/
7 2
/ /
9 6 3 1
解析过程：
class Solution {
public TreeNode invertTree(TreeNode root) {
//递归，先交换一下左右节点，然后再递归的交换左节点，右节点
//递归函数的终止条件，节点为空时返回
if(root == null){
return null;
}
//当前节点的左右子树进行交换
TreeNode temp=null;
temp=root.left;
root.left=root.right;
root.right=temp;
//递归
TreeNode left=invertTree(root.left);
TreeNode right=invertTree(root.right);
return root;
}
}
结果：
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：35.9 MB, 在所有 Java 提交中击败了54.20%的用户
通过测试用例：77 / 77
112. 路径总和
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。
叶子节点 是指没有子节点的节点。
提示：
树中节点的数目在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000
示例 1：
输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
示例 2：
输入：root = [1,2,3], targetSum = 5
输出：false
示例 3：
输入：root = [1,2], targetSum = 0
输出：false
解析过程：
class Solution {
public boolean hasPathSum(TreeNode root, int targetSum) {
//递归 DFS
return DFS(root,0,targetSum);
}
public boolean DFS(TreeNode root,int value,int targetSum){
if(root ==null){
return false;
}
value +=root.val;
if(root.left ==null && root.right == null){
return value == targetSum;
}else{
return DFS(root.left,value,targetSum) ||DFS(root.right,value,targetSum);
}
}
}
结果：
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：38.3 MB, 在所有 Java 提交中击败了59.60%的用户
通过测试用例：117 / 117
