leetcode 二叉树刷题汇总一

最新推荐文章于 2022-08-06 12:41:53 发布

原创最新推荐文章于 2022-08-06 12:41:53 发布 · 329 阅读

1 ·

CC 4.0 BY-SA版权

本文为博主原创文章，未经允许不得转载。如有问题，欢迎指正！

文章标签：

#二叉树 #leetcode #指针 #算法 #dfs

算法刷题专栏收录该内容

73 篇文章

订阅专栏

这篇博客涵盖了多种二叉树操作，包括构造二叉树的镜像、计算最大深度、求解直径以及进行前序、中序和后序遍历。通过递归实现这些操作，对于理解和处理二叉树问题具有重要意义。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题号—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 。

提示：
节点总数 <= 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. 二叉树的直径
给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

示例 :
给定二叉树

返回 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);
    }
};