代码随想录算法训练营：14/60

最新推荐文章于 2024-07-08 22:12:26 发布

Dustin_c

最新推荐文章于 2024-07-08 22:12:26 发布

阅读量769

点赞数 30

分类专栏：代码随想录文章标签：算法 leetcode c++ 数据结构

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/Dustin_c/article/details/139891622

版权

代码随想录专栏收录该内容

16 篇文章 1 订阅

订阅专栏

非科班学习算法day14 | LeetCode266:翻转二叉树，Leetcode101: 对称二叉树，Leetcode100:相同的的树，LeetCode572:另一颗树的子树，LeetCode104：二叉树的最大深度，LeetCode559：N叉树的最大深度

目录

一、基础概念补充：

1.二叉树的深度和高度

二、LeetCode题目

1.Leetcode226: 翻转二叉树

2.Leetcode101: 对称二叉树

3.Leetcode100:相同的树

4.Leetcode572:另一棵树的子树

5.Leetcode104: 二叉树的最大深度

6.Leetcode559: N叉树的最大深度

介绍

包含LC的几道题目，还有相应概念的补充。

相关图解和更多版本：

代码随想录 (programmercarl.com)https://programmercarl.com/#%E6%9C%AC%E7%AB%99%E8%83%8C%E6%99%AF

一、基础概念补充：

1.二叉树的深度和高度

代码随想录 (programmercarl.com)https://programmercarl.com/0104.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%A4%A7%E6%B7%B1%E5%BA%A6.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE

二、LeetCode题目

1.Leetcode226: 翻转二叉树

题目链接：226. 翻转二叉树 - 力扣（LeetCode）

题目解析

单层逻辑：交换左右两个孩子节点，所以采用后序遍历或者前序遍历都可以。

如果是采用层序遍历就要把每一层的结果记录之后反转。

递归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 {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (!root)
            return root;
        invertTree(root->left);
        invertTree(root->right);
        swap(root->left, root->right);

        return root;
    }
};

层序遍历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 {
public:
    TreeNode* invertTree(TreeNode* root) 
    {
        //层序遍历
        //建立辅助队列
        queue<TreeNode*> que;

        //插入根节点
        if(root != nullptr) 
        {
            que.push(root);
        }
        //初始化size
        int size = que.size();

        //层序遍历
        while(!que.empty())
        {
            while(size--)
            {
                //记录当前头节点
                TreeNode* cur_node = que.front();

                //弹出
                que.pop();

                //交换左右子节点
                swap(cur_node->left, cur_node->right);

                //加入当前左右节点
                if(cur_node->left != nullptr) que.push(cur_node->left);
                if(cur_node->right != nullptr) que.push(cur_node->right);
            }

            //更新size
            size = que.size();
        }
        
        //
        return root;
    }
};

2.Leetcode101: 对称二叉树

题目链接：101. 对称二叉树 - 力扣（LeetCode）

题目解析

首先就是一个误区就可能会默认把root的情况作为中止条件，那么不难发现，这样就可能需要回溯再比较节点的信息，实际上并没有这么复杂，依托示例给出的三层树就可以发现可以利用子节点的状态来分别检查左右两棵子树的信息，进而可以比较是否相同。

递归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 {
public:
    // 前序递归
    bool dfs(TreeNode* left, TreeNode* right) {
        if (left == nullptr && right == nullptr)
            return true;

        if (left != nullptr && right != nullptr && left->val == right->val) {
            // dfs(left->left, right->right);
            // dfs(left->right, right->left);
            return (dfs(left->left, right->right) &&
                    dfs(left->right, right->left));
        }

        return false;
    }
    bool isSymmetric(TreeNode* root) {
        if (!root)
            return true;
        return dfs(root->left, root->right);
    }
};

/**
 * 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 isSame(TreeNode* left, TreeNode* right)
    {
        if(!left&&!right)return true;
        else if(!left||!right) return false;
        else if(left->val != right->val) return false;
        else 
        {
            //检查外层
            bool outside = isSame(left->left, right->right);
            //检查内层
            bool inside = isSame(left->right, right->left);
            return outside&&inside;
        }
    }
    bool isSymmetric(TreeNode* root) 
    {
        return isSame(root->left, root->right);
    }
};

3.Leetcode100:相同的树

题目链接：100. 相同的树 - 力扣（LeetCode）

题目解析

101和572的思路和上面的题目的思路非常相近，细节处理不同罢了

递归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 {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) 
    {
        if(!p && !q) return true;
        
        else if(!p || !q) return false;
        else if(p->val != q->val) return false;
        
        //isSameTree(p->left, q->left);
        //isSameTree(p->right, q->right);
        else return bool(isSameTree(p->left, q->left)&&isSameTree(p->right, q->right));
    }
};

4.Leetcode572:另一棵树的子树

题目链接：572. 另一棵树的子树 - 力扣（LeetCode）

题目解析

101和572的思路和上面的题目的思路非常相近，细节处理不同罢了

递归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 {
public:
    bool isSametree(TreeNode* root, TreeNode* subRoot) {
        if (!root && !subRoot)
            return true;
        else if (!root || !subRoot)
            return false;
        else if (root && root->val == subRoot->val)
            return (isSametree(root->left, subRoot->left) &&
                    isSametree(root->right, subRoot->right));
        else
            return false;
    }
    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        if (!root)
            return false;
        if (isSametree(root, subRoot))
            return true;
        return isSubtree(root->left, subRoot) ||
               isSubtree(root->right, subRoot);
    }
};

5.Leetcode104: 二叉树的最大深度

题目链接：104. 二叉树的最大深度 - 力扣（LeetCode）

题目解析

把问题归结为最小单元，一层的二叉树，层数为一，最大深度为一；两层的二叉树，有左节点，没有右节点，最大深度为2......那么其实递推的过程就是在看左右最大路径然后返回这个值。

层序迭代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 {
public:
    int maxDepth(TreeNode* root) {
        // 建立辅助队列
        queue<TreeNode*> que;

        // 初始化层数
        int count = 0;

        // 插入根节点
        if (root != nullptr) {
            que.push(root);
        }

        // 初始化size
        int size = que.size();

        // 层序遍历求取层数
        while (!que.empty()) {
            while (size--) {
                // 保存头节点信息
                TreeNode* cur_node = que.front();

                // 弹出头节点
                que.pop();

                // 加入弹出节点的左右子节点
                if (cur_node->left != nullptr)
                    que.push(cur_node->left);
                if (cur_node->right != nullptr)
                    que.push(cur_node->right);
            }

            // 记录层数
            count++;

            // 更新size
            size = que.size();
        }
        return count;
    }
};

递归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 {
public:
    int maxDepth(TreeNode* root) 
    {
        //设置递归中止出口
        if(root == nullptr) return 0;

        //后序遍历递归体
        int depth_L = maxDepth(root->left);
        int depth_R = maxDepth(root->right);
        int maxdepth = max(depth_L, depth_R) + 1;
        return maxdepth;
    }
};

简洁版：

/**
 * 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 maxDepth(TreeNode* root) {
        // 设置递归中止出口
        if (root == nullptr)
            return 0;

        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }
};

注意点：在LeelCode中深度是按照节点数量算的，而不是边的数量。

6.Leetcode559: N叉树的最大深度

题目链接：559. N 叉树的最大深度 - 力扣（LeetCode）

题目解析

和二叉树最大的不同就是如何把多个分支都写出来。

递归C++代码如下：

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    int maxDepth(Node* root) {
        int cur_depth = 0;
        if (!root)
            return 0;

        for (auto child : root->children) {
            cur_depth = max(cur_depth, maxDepth(child));
        }
        return cur_depth + 1;
    }
};

总结

补打卡第14天，坚持！！！

关注

30
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营：14/60

包含LC的几道题目，还有相应概念的补充。补打卡第14天，坚持！！！
复制链接

扫一扫

专栏目录

Dustin_c CSDN认证博客专家 CSDN认证企业博客

码龄1年

25: 原创

7851: 周排名

4万+: 总排名

1万+: 访问

: 等级

693: 积分

364: 粉丝

440: 获赞

3: 评论

294: 收藏

私信

关注

热门文章

分类专栏

代码随想录 16篇

最新评论

代码随想录算法训练营：17/60
2401_85539784: 太棒啦！！！宝宝酱🥰
代码随想录算法训练营：13/60
2401_85539784: 亲亲😘
代码随想录算法训练营：4/60
2301_82243781: 这篇文章真是一篇佳作!作者运用了生动有趣的语言,将枯燥的理论知识娓娓道来,让人如沐春风。【我也写了一些相关领域的文章，希望能够得到博主的指导，共同进步！】
代码随想录算法训练营：1/60
CSDN-Ada助手: 恭喜你这篇博客进入【CSDN每天最佳新人】榜单，全部的排名请看 https://bbs.csdn.net/topics/618854522。

您愿意向朋友推荐“博客详情页”吗？

强烈不推荐
不推荐
一般般
推荐
强烈推荐

提交

最新文章

目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。