104. 二叉树的最大深度
- 用dfs 遍历一遍二叉树得出答案
/**
* 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;
* }
* }
*/
//解法1:通过遍历DFS类似
class Solution {
int count=0;
int max=0;
public int maxDepth(TreeNode root) {
dfs(root);
return max;
}
public void dfs(TreeNode root){
if(root==null){
max=Math.max(count,max);
return;
}
count++;
dfs(root.left);
count--;
count++;
dfs(root.right);
count--;
}
}
- 用动态规划的思想,递归得出答案
/**
* 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 maxDepth(TreeNode root) {
return dp(root);
}
public int dp(TreeNode root){
if(root==null) return 0;
return Math.max(dp(root.left)+1,dp(root.right)+1);
}
}
543. 二叉树的直径
/**
* 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 {
int maxCount=0;
public int diameterOfBinaryTree(TreeNode root) {
maxDept(root);
return maxCount;
}
public int maxDept(TreeNode root){
if(root==null) return 0;
int leftCount= maxDept(root.left);
int rightCount= maxDept(root.right);
int myCount=leftCount+rightCount;
maxCount=Math.max(myCount,maxCount);
return 1+Math.max(leftCount,rightCount);
}
}
226. 翻转二叉树
①遍历:
// 主函数
TreeNode invertTree(TreeNode root) {
// 遍历二叉树,交换每个节点的子节点
traverse(root);
return root;
}
// 二叉树遍历函数
void traverse(TreeNode root) {
if (root == null) {
return;
}
/**** 前序位置 ****/
// 每一个节点需要做的事就是交换它的左右子节点
TreeNode tmp = root.left;
root.left = root.right;
root.right = tmp;
// 遍历框架,去遍历左右子树的节点
traverse(root.left);
traverse(root.right);
}
② 分解问题思路:
/**
* 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 {
//假想invertTree 函数是将root 节点的左右子树交换了的结果;
public TreeNode invertTree(TreeNode root) {
if(root==null) return null;
TreeNode left= invertTree(root.left);
TreeNode right=invertTree(root.right);
root.left=right;
root.right=left;
return root;
}
}
116. 填充每个节点的下一个右侧节点指针
①遍历每个节点
/*
// Definition for a Node.
class Node {
public int val;
public Node left;
public Node right;
public Node next;
public Node() {}
public Node(int _val) {
val = _val;
}
public Node(int _val, Node _left, Node _right, Node _next) {
val = _val;
left = _left;
right = _right;
next = _next;
}
};
*/
class Solution {
public Node connect(Node root) {
if(root==null) return root;
traverse(root.left,root.right);
return root;
}
public void traverse(Node root1,Node root2){
if(root1==null||root2==null) return;
root1.next=root2;
traverse(root1.left,root1.right);
traverse(root1.right,root2.left);
traverse(root2.left,root2.right);
}
}
114. 二叉树展开为链表
用分解法,分三步
/**
* 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 void flatten(TreeNode root) {
dp(root);
}
//将以root 为根节点的树,展开为一条链表
public void dp(TreeNode root){
if(root==null) return;
//将左右子树都变成一条链
dp(root.left);
dp(root.right);
//将root 的右指针指向左节点
TreeNode left= root.left;
TreeNode right= root.right;
root.right=left;
root.left=null;
//将root 的原来右子树拼接到变成链的左子树的下面
while(root!=null&&root.right!=null){
root=root.right;
}
root.right=right;
}
}
654. 最大二叉树
如果单独抽出一个二叉树节点,它需要做什么事情?需要在什么时候(前/中/后序位置)做?其他的节点不用你操心,递归函数会帮你在所有节点上执行相同的操作。
二叉树的构造问题一般都是使用「分解问题」的思路:构造整棵树 = 根节点 + 构造左子树 + 构造右子树。用分解法
/**
* 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 TreeNode constructMaximumBinaryTree(int[] nums) {
int n=nums.length;
return dp(nums,0,n-1);
}
//表示构建了一个以root为根的最大二叉树
public TreeNode dp(int[] nums,int start,int end){
if(start>end) return null;
//找出数组中最大值和最大的索引
int index=-1; int max=Integer.MIN_VALUE;
for(int i=start;i<=end;i++){
if(nums[i]>max){
max=nums[i];
index=i;
}
}
TreeNode root=new TreeNode(max);
TreeNode l= dp(nums,start,index-1);
root.left=l;
TreeNode r= dp(nums,index+1,end);
root.right=r;
return root;
}
}
105. 从前序与中序遍历序列构造二叉树
/**
* 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 TreeNode buildTree(int[] preorder, int[] inorder) {
int n=preorder.length;
return build(preorder,0,n-1,inorder,0,n-1);
}
//构建一个以root 为根的二叉树
public TreeNode build(int[] preorder,int preStart,int preEnd,int[] inorder,int inStart,int inEnd){
if(preStart>preEnd) return null;
int preVal=preorder[preStart];
int index=-1;
for(int i=inStart;i<=inEnd;i++){
if(inorder[i]==preVal){
index=i;
break;
}
}
int leftSize=index-inStart;
TreeNode root=new TreeNode(preVal);
root.left= build(preorder,preStart+1,preStart+leftSize,inorder,inStart,index-1);
root.right=build(preorder,preStart+leftSize+1,preEnd,inorder,index+1,inEnd);
return root;
}
}