这篇博客涵盖了多种二叉树操作，包括构造二叉树的镜像、计算最大深度、求解直径以及进行前序、中序和后序遍历。通过递归实现这些操作，对于理解和处理二叉树问题具有重要意义。
题号—NO.1(简单)
题目链接：leetcode 剑指 Offer 27. 二叉树的镜像
请完成一个函数，输入一个二叉树，该函数输出它的镜像。
例如输入：
4 / \ 2 7 / \ /\ 1 3 6 9
镜像输出：
4 / \ 7 2 / \ /\ 9 6 3 1
示例 1：
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]
限制：
0 <= 节点个数 <= 1000
分析
把每个节点的左右儿子交换即可实现上述效果。具体操作就是在dfs访问节点时让每个节点右儿子指针指向左儿子、左儿子指针指向右儿子。其实其实就是交换二者的“地址”，交换时加一个中间变量即可。
C++代码
//C++ 代码：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
void dfs(TreeNode* root){
if(root==NULL) return;
TreeNode * p=root->left; //中间变量指向左儿子
root->left=root->right; //左儿子指向左儿子
root->right=p; //右儿子指向中间变量(即最初的左儿子)
dfs(root->left);
dfs(root->right);
}
TreeNode* mirrorTree(TreeNode* root) {
dfs(root);
return root;
}
};
Java代码
// Java代码:
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
void dfs(TreeNode root){
if(root==null) return;
TreeNode p=root.left; //中间变量指向左儿子
root.left=root.right; //左儿子指向左儿子
root.right=p; //右儿子指向中间变量(即最初的左儿子)
dfs(root.left);
dfs(root.right);
}
public TreeNode mirrorTree(TreeNode root) {
dfs(root);
return root;
}
}
题号—NO.2(简单)
题目链接：leetcode 剑指 Offer 55 - I. 二叉树的深度
输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。
例如：
给定二叉树 [3,9,20,null,null,15,7]，
3 / \ 9 20 / \ 15 7
返回它的最大深度 3 。
提示：
节点总数 <= 10000
C++代码
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int maxDepth(TreeNode* root) {
if(root==NULL) return 0; //节点为空则深度为0
//递归求最大支路深度
return max(maxDepth(root->left)+1,maxDepth(root->right)+1);
}
};
Java代码
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public int maxDepth(TreeNode root) {
if(root==null) return 0; //节点为空则深度为0
//递归求最大支路深度
return Math.max( maxDepth(root.left)+1, maxDepth(root.right)+1);
}
}
题号—NO.3(简单)
题目链接：leetcode 543. 二叉树的直径
给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。
示例 :
给定二叉树
1
/ \
2 3
/ \
4 5
返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。
注意：两结点之间的路径长度是以它们之间边的数目表示。
C++代码
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
private:
int res=INT_MIN;
public:
int dfs(TreeNode* root){
if(root==nullptr) return 0;
int d=0;
int l=dfs(root->left);
int r=dfs(root->right);
d=max(l+1,r+1);
res=max(res,l+r);
return d;
}
int diameterOfBinaryTree(TreeNode* root) {
dfs(root);
return res;
}
};
Java代码
/**
* 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 res=Integer.MIN_VALUE;
int dfs(TreeNode root){
if(root==null) return 0;
int l=dfs(root.left);
int r=dfs(root.right);
int d=Math.max(r+1,l+1);
res=Math.max(res,l+r);
return d;
}
public int diameterOfBinaryTree(TreeNode root) {
dfs(root);
return res;
}
}
题号—NO.4(简单)
题目链接：二叉树的前序遍历
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
note:
前序遍历：“根左右”（先访问根再访问左儿子最后访问右儿子）
C++代码
class Solution {
private:
vector<int>res;
public:
//前序遍历：“根左右”（先访问根再访问左儿子最后访问右儿子）
void dfs(TreeNode* root){
if(root==nullptr) return;
res.push_back(root->val);
dfs(root->left);
dfs(root->right);
}
vector<int> preorderTraversal(TreeNode* root) {
dfs(root);
return res;
}
};
题号—NO.5(简单)
题目链接：二叉树的中序遍历
给定一个二叉树的根节点 root ，返回它的 中序 遍历。
note
中序遍历：“左根右”（先访问左儿子再访问根最后访问右儿子）
C++代码
class Solution {
private:
vector<int>res;
public:
//中序遍历：“左根右”（先访问左儿子再访问根最后访问右儿子）
void dfs(TreeNode* root){
if(root==nullptr) return;
dfs(root->left);
res.push_back(root->val);
dfs(root->right);
}
vector<int> inorderTraversal(TreeNode* root) {
dfs(root);
return res;
}
};
题号—NO.6(简单)
题目链接：二叉树的后序遍历
给定一个二叉树，返回它的 后序 遍历。
note
后序遍历：“左右根”（先访问左儿子再访问右儿子最后访问根）
C++代码
class Solution {
private:
vector<int>res;
public:
//后序遍历：“左右根”（先访问左儿子再访问右儿子最后访问根）
void dfs(TreeNode* root){
if(root==nullptr) return;
dfs(root->left);
dfs(root->right);
res.push_back(root->val);
}
vector<int> postorderTraversal(TreeNode* root) {
dfs(root);
return res;
}
};
题号—NO.7(简单)
leetcode 112. 路径总和
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。
叶子节点 是指没有子节点的节点。
示例 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
分析
dfs搜一条和为targetSum的路径即可。在搜索的时候用targetSum减去路径上节点的值，若搜到叶子节点时targetSum减为0,则存在满足要求的路径。需要注意的是，叶子节点是指没有子节点的节点。即没有左儿子也没有右儿子的节点才是叶子节点。
C++代码
class Solution {
public:
bool dfs(TreeNode* root, int targetSum){
if(root==NULL) return false;
if(root->left==NULL&&root->right==NULL&&targetSum==root->val) return true;
else if(root->left==NULL&&root->right==NULL&&targetSum!=root->val) return false;
return dfs(root->left,targetSum-root->val)||dfs(root->right,targetSum-root->val);
}
bool hasPathSum(TreeNode* root, int targetSum) {
return dfs(root,targetSum);
}
};
扫一扫
415
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
