代码训练营 day 14|LeetCode 226，LeetCode 101，LeetCode 104，LeetCode 111

最新推荐文章于 2024-09-29 16:57:04 发布

西几

最新推荐文章于 2024-09-29 16:57:04 发布

阅读量562

点赞数 8

分类专栏：代码训练营刷题记录文章标签： leetcode 算法 c++

本文链接：https://blog.csdn.net/qq_44639909/article/details/142502109

版权

代码训练营刷题记录专栏收录该内容

16 篇文章 0 订阅

订阅专栏

前言

这里记录一下陈菜菜的刷题记录，主要应对25秋招、春招
个人背景
211CS本+CUHK计算机相关硕，一年车企软件开发经验
代码能力：有待提高
常用语言：C++

系列文章目录

第一天数组 part01

第二天数组 part02

第三天链表 part01

第四天链表 part02

第五天休息

第六天哈希表 part01

第七天：第三章哈希表part02

第八天：第四章字符串part01

第九天：第四章字符串part02

第十天：第五章栈与队列part01

第十一天：第五章栈与队列part02

第十三天：第六章二叉树part01

第十四天：第六章二叉树part02

一、今日任务

● 226.翻转二叉树
● 101. 对称二叉树
● 104.二叉树的最大深度
● 111.二叉树的最小深度

二、详细布置

226.翻转二叉树

题目链接：[力扣226]https://leetcode.cn/problems/invert-binary-tree/)
文章讲解：代码随想录
视频讲解：代码随想录

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

提示：

树中节点数目范围在 [0, 100] 内
-100 <= Node.val <= 100

样例1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

样例2：

输入：root = [2,1,3]
输出：[2,3,1]

思路

这题简单题，两个栈实现。

实战

/**
 * 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 {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root==NULL)
            return root;
        swap(root->left,root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

101. 对称二叉树（优先掌握递归）

题目链接：力扣101题链接
文章讲解：图文讲解

给你一个二叉树的根节点 root ，检查它是否轴对称。

提示：

树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100

样例1：

输入：root = [1,2,2,3,4,4,3]
输出：true

思路

这题真不简单题。一开始打算用层序遍历，再判断每行数字是不是回文串的。结果遇到NULL节点就不行了，没办法把替代值按她的顺序压入队列。这里留个言，希望能找到好方法解决这个问题。

实战

/**
 * 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 {
public:
    bool compare(TreeNode* left,TreeNode* right){
            if(left==NULL&&right==NULL)
                return true;
            else if(left!=NULL&&right==NULL)
                return false;
            else if(left==NULL&&right!=NULL)
                return false;
            else if(left->val!=right->val)
                return false;

            bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
            bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
            bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
            return isSame;
        }
    bool isSymmetric(TreeNode* root) {
        
        if(root==NULL)
            return true;
        return compare(root->left,root->right);

    }
};

踩坑

层序遍历的方法还没解决。
这题递归真的很巧妙，是在处理完空节点后递归。

104.二叉树的最大深度

题目链接：LeetCode104
文章讲解：图文讲解

题目描述

给定一个二叉树 root ，返回其最大深度。

二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。

提示：

树中节点的数量在 [0, 104] 区间内。
-100 <= Node.val <= 100

样例1：

输入：root = [3,9,20,null,null,15,7]
输出：3

样例2：

输入：root = [1,null,2]
输出：2

思路

递归，常规题。码一下非递归算法。

实战

class Solution {
public:
    int getdepth(TreeNode* node) {
        if (node == NULL) return 0;
        int leftdepth = getdepth(node->left);       // 左
        int rightdepth = getdepth(node->right);     // 右
        int depth = 1 + max(leftdepth, rightdepth); // 中
        return depth;
    }
    int maxDepth(TreeNode* root) {
        return getdepth(root);
    }
};

111.二叉树的最小深度

题目链接：111
文章讲解：图文讲解

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

提示：

树中节点数的范围在 [0, 105] 内
-1000 <= Node.val <= 1000

样例1：

输入：root = [3,9,20,null,null,15,7]
输出：2

思路

这题跟最大深度很像，唯一区别就是特殊情况：极不平衡子树。就是只有左子树/只有右子树。但是求左右子树高度依然是递归的。只要加上限定条件：当子树有一个高度为0，另一个不为0——说明是单子树，就得用较大的那个子树高度表示高度（因为另一半为空）。其余情况就是返回较小的数作为最小高度。

实战

/**
 * 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 {
public:
    
        

    int getdepth(TreeNode* node) {
        if (node == NULL) return 0;
        int leftdepth = getdepth(node->left);       // 左
        int rightdepth = getdepth(node->right);     // 右
        int depth;
        if(leftdepth==0&&rightdepth!=0||leftdepth!=0&&rightdepth==0)
            depth = 1 + max(leftdepth, rightdepth); // 中
        else
            depth = 1 + min(leftdepth, rightdepth);
        return depth;
    }
    int minDepth(TreeNode* root) {
        return getdepth(root);
    }
};