Studying-代码随想录训练营day14| 226.翻转二叉树、101.对称二叉树、104.二叉树的最大深度、111.二叉树的最小深度

news2024/11/15 19:41:24

第十四天，(ง •_•)ง💪💪，编程语言：C++

目录

226.翻转二叉树

101.对称二叉树

100.相同的树 

572.另一个树的子树

104.二叉树的最大深度

559.n叉树的最大深度

111.二叉树的最小深度

总结

226.翻转二叉树

文档讲解：代码随想录翻转二叉树

视频讲解：手撕翻转二叉树

题目：

初看：本题翻转二叉树不仅仅是把根节点的左右子树进行了翻转，也把子节点下面的左右子树都进行了翻转。需要对所有中间节点（非叶子节点）进行处理。

代码：前序遍历（递归法）

//时间复杂度O(n)
//空间复杂度O(n)
class Solution {
public:
    void reverseNode(TreeNode* root) {
        if (root == nullptr || (root->left == nullptr && root->right == nullptr)) return;
        TreeNode* tmp = root->left; //中
        root->left = root->right;
        root->right = tmp;
        //swap(root->left, root->right);

        reverseNode(root->left); //左
        reverseNode(root->right);//右
    }
    TreeNode* invertTree(TreeNode* root) { 
        reverseNode(root);
        return root;
    }
};

代码： 层次遍历（广度优先遍历）

//时间复杂度O(n)
//空间复杂度O(n)
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right); // 节点处理
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

注意：此题能够使用前序遍历和后序遍历，逻辑基本一致，但如果采用中序遍历的方式，要注意把中节点处理后，右子树就变成了左子树，左子树就变成了右子树，因此下次处理的时候仍应处理的是左子树（原右子树）

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        invertTree(root->left);         // 左
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 注意 这里依然要遍历左孩子，因为中间节点已经翻转了
        return root;
    }
};

101.对称二叉树

文档讲解：代码随想录对称二叉树

视频讲解：手撕对称二叉树

题目：

初看：对称二叉树从根节点开始，往下比较左右节点，之后往下需要分为两条道路，一条左右子树的外层节点，一条比较左右子树的内层节点。因此实际上是比较左右两棵树是否相等。

代码：后序遍历(递归法）

//时间复杂度O(n)
//空间复杂度O(n)
class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        if(left == NULL && right == NULL) return true; //都为空返回true
        else if(left == NULL || right == NULL) return false; //有一个为空另一个不为空（都为空前面判断了）返回false
        else if(left->val != right->val) return false; //都不为空但是值不相等
        else { //都不为空且值相等，向下继续遍历
            bool outside = compare(left->left, right->right); //外侧比较
            bool inside = compare(left->right, right->left); //内测比较
            return outside && inside; //都为true才返回true；
        }
    }
    //递归法
    bool isSymmetric(TreeNode* root) {
        if(root == nullptr) return true;
        return compare(root->left, root->right);
    }
};

学习：

  1. 本题需要遍历两棵树而且要比较内侧和外侧的节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。这都可以理解为一种后序遍历，把孩子的信息反馈到父节点身上。
  2. 本题的递归三部曲：①确定递归函数的参数和返回值：本题需要比较左右子树，因此参数肯定为左子树和右子树的节点，其次本题是判断正确，因此返回bool类型。②确定终止条件：用清楚节点存在的情况：左节点为空，右节点不为空；左不为空，右为空；左右都为空；左右都不为空，比较节点数值。③确定单层递归逻辑：左右节点都不为空，且数值相同时才进入单层递归的逻辑。单层递归的逻辑就是比较：比较二叉树外侧是否对称，传入的是左节点的左孩子，右节点的右孩子；比较内侧是否对称，传入左节点的右孩子，右节点的左孩子；如果左右都对称就返回true ，有一侧不对称就返回false。

代码：迭代法，注意加入节点的顺序即可

class Solution {
public:
    //迭代法
    bool isSymmetric(TreeNode* root) {
        queue<TreeNode*> que;
        if(root == nullptr) return true;

        que.push(root->left);
        que.push(root->right);
        while(!que.empty()) {
            TreeNode* left = que.front();
            que.pop();
            TreeNode* right = que.front();
            que.pop();

            if(left == NULL && right == NULL) continue; //都为空进行后序节点比较
            else if(left == NULL || right == NULL) return false; //有一个为空另一个不为空（都为空前面判断了）返回false
            else if(left->val != right->val) return false; //都不为空但是值不相等
            else {
                //按顺序加入节点
                que.push(left->left);   // 加入左节点左孩子
                que.push(right->right); // 加入右节点右孩子
                que.push(left->right);  // 加入左节点右孩子
                que.push(right->left);  // 加入右节点左孩子
            }
        }
        return true;
    }
};

注意：迭代法中使用了队列，但实际上并不是层序遍历，而是仅仅通过一个容器来成对的存放我们要比较的元素，知道这一本质之后就发现，用队列，用栈，甚至用数组，都是可以的。

其他题目：

100.相同的树 

题目：

初看：和左右子树对称一样，只不过没有了 根节点，比较的节点也变为了一一对应的关系。

代码：

//时间复杂度O(min(m,n))
//空间复杂度O(min(m,n))
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        queue<TreeNode*> que;
        if (!p && !q) return true;
        //载入两个节点依次进行判断
        que.push(p);
        que.push(q);
        while(!que.empty()) {
            //取出需要比较的节点
            TreeNode* node1 = que.front(); que.pop();
            TreeNode* node2 = que.front(); que.pop();
            if (node1 == nullptr && node2 == nullptr) continue; //都为空进行下一轮判断
            else if (node1 == nullptr || node2 == nullptr) return false; //有一个不为空，返回错误
            else if (node1->val != node2->val) return false; //都不为空但是值不等
            else {
                //注意载入节点的顺序
                que.push(node1->left);
                que.push(node2->left);
                que.push(node1->right);
                que.push(node2->right);
            }
        }
        return true;
    }
};

572.另一个树的子树

题目：

初看： 本题事实上与找到相同的树是一样的，只不过它还需要遍历每一个节点。

代码：

//时间复杂度O(n*m)
class Solution {
public:
    //暴力匹配==寻找相同的树
    bool compare(TreeNode* root, TreeNode* subRoot) {
        queue<TreeNode*> que;
        //载入两个节点依次进行判断
        que.push(root);
        que.push(subRoot);
        while(!que.empty()) {
            //取出需要比较的节点
            TreeNode* node1 = que.front(); que.pop();
            TreeNode* node2 = que.front(); que.pop();
            if (node1 == nullptr && node2 == nullptr) continue; //都为空进行下一轮判断
            else if (node1 == nullptr || node2 == nullptr) return false; //有一个不为空，返回错误
            else if (node1->val != node2->val) return false; //都不为空但是值不等
            else {
                //注意载入节点的顺序
                que.push(node1->left);
                que.push(node2->left);
                que.push(node1->right);
                que.push(node2->right);
            }
        }
        return true;
    }
    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        //广度优先遍历+暴力匹配
        //广度优先遍历
        queue<TreeNode*> que;
        if (root != nullptr) que.push(root);
        if (subRoot == nullptr) return true;
        bool result;

        while (!que.empty()) {
            TreeNode* node = que.front(); que.pop();
            if (node->val == subRoot->val) {
                result = compare(node, subRoot);
                cout << result << endl;
                if(result == true) return true;
            }
            if(node->left) que.push(node->left);
            if(node->right) que.push(node->right);
        }
        return false;
    }
};

注意：本题还可以采用KMP算法，和哈希筛选等方法，但过于复杂不利于理解，故没有给出。可前往力扣查看对应例题详解。

104.二叉树的最大深度

文本讲解： 代码随想录二叉树的最大深度

视频讲解：手撕二叉树的最大深度

题目：

学习：昨天使用了层次遍历的方式求解本题，实际上本题也可以使用深度优先遍历的方式来进行求解。本题是要查找树的最大深度，实际上这与树的高度是一一对应的，根节点的高度就是树的最大深度，因此可以采取前序遍历和后序遍历的方式，来查找根节点的高度。

代码：后序遍历（递归法）

注：相当于每次递归后depth深度+1，之后返回左子树和右子树之中最大的那个深度。

//时间复杂度O(n)
//空间复杂度O(n)
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);
    }
};

代码：前序遍历（递归法）

注：前序遍历相比之下复杂一些，这是因为它需要先处理节点，再进行递归，因此需要一个辅助量result，每次递归前进行赋值判断。实际含义就是先找寻左子树中最大深度，保存最大深度，然后看右子树有没有更大的深度，再进行赋值。

class Solution {
public:
    int result;
    void getdepth(TreeNode* node, int depth) {
        result = depth > result ? depth : result; // 中

        if (node->left == NULL && node->right == NULL) return ;

        if (node->left) { // 左
            depth++;    // 深度+1
            getdepth(node->left, depth);
            depth--;    // 回溯，深度-1
        }
        if (node->right) { // 右
            depth++;    // 深度+1
            getdepth(node->right, depth);
            depth--;    // 回溯，深度-1
        }
        return ;
    }
    int maxDepth(TreeNode* root) {
        result = 0;
        if (root == NULL) return result;
        getdepth(root, 1);
        return result;
    }
};

其他题目：

559.n叉树的最大深度

题目：

学习：本题和求二叉树的最大深度逻辑基本相同，只不过是把左右孩子换成了一个数组，增加一个for循环遍历孩子即可。

代码：层次遍历

//时间复杂度O(n)
//空间复杂度O(n)
class Solution {
public:
    int maxDepth(Node* root) {
        //最大深度就是需要遍历的层数
        queue<Node*> que;
        int depth = 0; //记入深度
        if (root != nullptr) que.push(root);

        while (!que.empty()) {
            int size = que.size();
            //每进行循环深度加1
            depth++;
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                for (auto it = node->children.begin(); it != node->children.end(); it++) {
                    que.push(*it);
                }
            }
        }
        return depth;
    }
};

代码：后序遍历（递归法）

//时间复杂度O(n)
//空间复杂度O(n)
class Solution {
public:
    int maxDepth(Node* root) {
        if (root == 0) return 0;
        int depth = 0;
        //求孩子的最大深度
        for (int i = 0; i < root->children.size(); i++) {
            depth = max (depth, maxDepth(root->children[i]));
        }
        //加上根节点
        return depth + 1;
    }
};

111.二叉树的最小深度

文档讲解：代码随想录二叉树的最小深度

视频讲解：手撕二叉树的最小深度

题目：

学习： 昨天同样也是用了层次遍历的方法求解本题，本题也能够使用迭代法进行处理，但需要注意的是，只有遍历到叶子节点（左右节点都没有时）才算是遍历到了合法的深度位置。

代码：后序遍历（递归）

//时间复杂度O(n)
//空间复杂度O(n)
class Solution {
public:
    int getDepth(TreeNode* node) {
        if (node == NULL) return 0;
        int leftDepth = getDepth(node->left);           // 左
        int rightDepth = getDepth(node->right);         // 右
                                                        // 中
        //只有遍历到一个树的叶子节点（没有孩子）才算是终止
        // 当一个左子树为空，右不为空，这时并不是最低点，它可能还有孩子
        if (node->left == NULL && node->right != NULL) { 
            return 1 + rightDepth;
        }   
        // 当一个右子树为空，左不为空，这时并不是最低点，它可能还有孩子
        if (node->left != NULL && node->right == NULL) { 
            return 1 + leftDepth;
        }
        //两边都有孩子才取最小的深度
        int result = 1 + min(leftDepth, rightDepth);
        return result;
    }
    int minDepth(TreeNode* root) {
        return getDepth(root);
    }
};

代码：层次遍历

class Solution {
public:
    int minDepth(TreeNode* root) {
        //最小深度，就是在遍历每一层节点的时候，如果发现该节点没有子节点则停下循环。
        queue<TreeNode*> que;
        int depth = 0; //记入深度
        if (root != nullptr) que.push(root);

        while (!que.empty()) {
            int size = que.size();
            //每进行循环深度加1
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (node->right == nullptr && node->left == nullptr) {
                    return depth;
                }
            }
        }
        return depth;
    }
};

总结

二叉树遍历有两种方式：广度优先遍历，深度优先遍历。深度优先遍历又分为三种：前序遍历、后序遍历、中序遍历。广度优先遍历就是层次遍历。

二叉树遍历的代码有三种：递归法求前中后序遍历，迭代法使用栈求前中后序遍历，迭代法使用队列求层次遍历。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1865153.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

笔记-python reduce 函数

笔记-python reduce 函数

reduce() 函数在 python 2 是内置函数&#xff0c; 从python 3 开始移到了 functools 模块。 官方文档是这样介绍的 reduce(...) reduce(function, sequence[, initial]) -> valueApply a function of two arguments cumulatively to the items of a sequence, from left …
阅读更多...
HarmonyOS Next开发学习手册——进程模型线程模型

HarmonyOS Next开发学习手册——进程模型线程模型

进程模型 系统的进程模型如下图所示&#xff1a; 应用中&#xff08;同一包名&#xff09;的所有PageAbility、ServiceAbility、DataAbility、FormAbility运行在同一个独立进程中&#xff0c;即图中绿色部分的“Main Process”。 WebView拥有独立的渲染进程&#xff0c;即图中…
阅读更多...
Redis-实战篇-缓存雪崩

Redis-实战篇-缓存雪崩

文章目录 1、缓存雪崩2、解决方案&#xff1a; 1、缓存雪崩 缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机&#xff0c;导致大量请求到达数据库&#xff0c;带来巨大压力。 2、解决方案&#xff1a; 给不同的key的TTL添加随机值利用Redis集群提高服务的可用性…
阅读更多...
OpenAI API一键搬家，天工推出开发者迁移计划

OpenAI API一键搬家，天工推出开发者迁移计划

6月25日&#xff0c;OpenAI宣布称将于今年7月9日开始封锁来自非支持国家和地区的API流量。此后&#xff0c;来自中国大陆、中国香港等地的开发者将无法使用OpenAI API提供服务。 为了助力开发者高效切换至国内大模型&#xff0c;天工开放平台&#xff08;https://model-platfo…
阅读更多...
工业网关的功能与作用解析-天拓四方

工业网关的功能与作用解析-天拓四方

在工业4.0和智能制造的时代背景下&#xff0c;工业网关作为连接现场设备与云端平台的桥梁&#xff0c;正发挥着日益重要的作用。它不仅为工业设备的远程监控和管理提供了可能&#xff0c;还为企业实现数字化转型和智能化升级提供了有力支持。本文将对工业网关的功能与作用进行解…
阅读更多...
【SpringBoot Actuator】⭐️Actuator 依赖实现服务健康检查，线程信息收集

【SpringBoot Actuator】⭐️Actuator 依赖实现服务健康检查，线程信息收集

目录 &#x1f378;前言 &#x1f37b;一、Actuator 了解 &#x1f37a;二、使用 2.1 依赖引入 2.2 测试场景搭建 &#x1f379;三、测试 3.1 项目启动测试 3.2 服务健康检查 3.3 线程转储 3.4 内存使用&#xff0c;垃圾回收信息获取 &#x1f49e;️四、章末 &#x1…
阅读更多...
程序猿大战Python——正则表达式——正则概述

程序猿大战Python——正则表达式——正则概述

正则表达式的概述 基本介绍 目标&#xff1a;了解什么是正则表达式&#xff1f; 正则表达式&#xff0c;也叫做规则表达式&#xff0c;通常会说成【正则】。 实际上&#xff0c;正则表达式就是指符合一定规则的字符串&#xff0c;同时它能用于检查一段文本数据是否与某种模式…
阅读更多...
IND87520芯片介绍(二)

IND87520芯片介绍(二)

六、内部模拟调光 一个精确的10位DAC作为BUCK电流调节回路的参考发生器。与SPI通信时&#xff0c;DAC参考电压可由主机改变并调节电流在BUCK不断切换的同时&#xff0c;也会发生相应的变化。10位分辨率的DAC正在设计中满足电流变化平稳的要求。一个1.713mA电流步使光亮度连续变…
阅读更多...
首次30米空间分辨率生成中国年度耕地栅格数据1986-2021

首次30米空间分辨率生成中国年度耕地栅格数据1986-2021

中国1986-2021年30米分辨率年度耕地数据集 数据介绍 精确、详细且及时的耕地范围信息对于粮食安全保障和环境可持续性至关重要。然而&#xff0c;由于农业景观的复杂性和足够训练样本的缺乏&#xff0c;在大范围下进行高时空分辨率的耕地动态监测仍然具有挑战性&#xff0c;尤其…
阅读更多...
Matlab|【免费】含氢气氨气综合能源系统优化调度

Matlab|【免费】含氢气氨气综合能源系统优化调度

目录 主要内容 部分代码 结果一览 下载链接 主要内容 该程序参考《_基于氨储能技术的电转氨耦合风–光–火综合能源系统双层优化调度》模型&#xff0c;对制氨工厂、风力发电、电制氢、燃气轮机、火电机组等主体进行建模分析&#xff0c;以火电机组启停成本、煤耗…
阅读更多...
ubuntu中共享文件夹看不到了，解决方法

ubuntu中共享文件夹看不到了，解决方法

1、检查共享文件夹配置 2、创建 3、查看共享文件夹 4、另一问题&#xff0c;每次重启虚拟机后&#xff0c;共享文件夹又没了&#xff1f;
阅读更多...
三大办公软件实用小技巧 沈阳办公软件白领必修班

三大办公软件实用小技巧 沈阳办公软件白领必修班

Word 学好办公软件能大大的提升我们的工作效率。下面让我们一起学习一下Word办公软件时几个实用小技巧&#xff01; 01.快速插入当前日期或时间 在使用Word办公软件进行文档的编辑处理时&#xff0c;如果需要在文章的末尾插入系统的当前日期或时间。通常情况下&#xff0c;我…
阅读更多...
洞察用户需求，Xinstall数据统计App让你的App运营如虎添翼

洞察用户需求，Xinstall数据统计App让你的App运营如虎添翼

在互联网时代&#xff0c;App推广和运营面临着前所未有的挑战。流量红利逐渐衰退&#xff0c;用户获取成本不断攀升&#xff0c;如何确保在多变的互联网环境下&#xff0c;迅速搭建起能时刻满足用户需求的运营体系&#xff0c;成为众多企业急待解决的问题。今天&#xff0c;我们…
阅读更多...
disableSplitter(false)和requestInputBufSize(0)一样吗？

disableSplitter(false)和requestInputBufSize(0)一样吗？

编译omx文件时&#xff0c;在disableSplitter(false)前加了requestInputBufSize(0)导致报错 hardware/media/hardware/omx/vdec/omx_vdec3.cpp" vendor/realtek/common/ATV/hardware/media/hardware/omx/vdec/omx_vdec3.cpp:245:3: error: field requestInputBufSize wi…
阅读更多...
ONLYOFFICE 8.1：引领桌面办公新潮流，功能升级全面提升

ONLYOFFICE 8.1：引领桌面办公新潮流，功能升级全面提升

目录 一、ONLYOFFICE是什么&#xff1f; 二、功能完善的PDF编辑器 三、幻灯片版式升级 四、改进从右至左显示 五、新的本地化选项 六、多媒体功能增强 七、应用价值探讨 一、ONLYOFFICE是什么&#xff1f; ONLYOFFICE 是一款功能强大的办公套件&#xff0c;旨在提供全面…
阅读更多...
如何从0构建一款类似pytest的工具

如何从0构建一款类似pytest的工具

Pytest主要模块 Pytest 是一个强大且灵活的测试框架&#xff0c;它通过一系列步骤来发现和运行测试。其核心工作原理包括以下几个方面&#xff1a;测试发现&#xff1a;Pytest 会遍历指定目录下的所有文件&#xff0c;找到以 test_ 开头或 _test.py 结尾的文件&#xff0c;并且…
阅读更多...
ozon测评自养号必备技巧：提升账号质量，降低测评成本

ozon测评自养号必备技巧：提升账号质量，降低测评成本

OZON测评自养号技巧 1.提高店铺权重 自主测评&#xff1a;通过自养号的方式&#xff0c;卖家可以自主控制测评的时间和数量&#xff0c;为自己的listing进行测评&#xff0c;提高店铺权重。 策略调整&#xff1a;根据市场情况和商品特点&#xff0c;灵活调整测评策略&#x…
阅读更多...
如何编写时区源文件

如何编写时区源文件

0、背景 ① 修改TZ环境变量改变时区不能立即生效。要求设置时区后立即生效&#xff0c;只能用修改/etc/localtime方式。 ② 原文作者 Bill Seymour&#xff0c;想要查看原文&#xff0c;点击官网地址https://www.iana.org/time-zones下载 zic 源码&#xff0c;源码目录中的 tz…
阅读更多...
VS Code修改菜单栏字体大小

VS Code修改菜单栏字体大小

修改方法 打开VS Code&#xff0c;快捷键 CtrlShiftP&#xff0c;在弹出的输入框中输入 setting&#xff0c;找到带有JSON的一项&#xff0c;如图所示&#xff1a; 原文链接 window.zoomLevel 前后变化 终端字体大小 File -> Preferences -> Settings -> Features…
阅读更多...
Linux驱动开发-02字符设备驱动开发初步

Linux驱动开发-02字符设备驱动开发初步

一、驱动开发的前期准备 在进入驱动开发之前&#xff0c;需要烧写UBoot、内核、设备树&#xff0c;做一些前期的准备工作&#xff0c;确保我们开发板上的内核版本和Ubuntu上是一致的才能进行正式开发 1.U-Boot 2.内核版本 3.使用TFTP挂载的内核和设备树 二、Linux驱动开发与裸机…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023