刷题了：144.二叉树的前序遍历心|145.二叉树的后序遍历心|94.二叉树的中序遍历己

news2024/9/17 7:10:21

递归遍历

文章讲解:https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E9%80%92%E5%BD%92%E9%81%8D%E5%8E%86.html#%E6%80%9D%E8%B7%AF
视频讲解:https://www.bilibili.com/video/BV1Wh411S7xt/?spm_id_from=333.788&vd_source=e70917aa6392827d1ccc8d85e19e8375
题目链接:https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E9%80%92%E5%BD%92%E9%81%8D%E5%8E%86.html#%E6%80%9D%E8%B7%AF
实现情况：

/**
 * 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:
    void traversal(TreeNode *cur,vector<int>& vec){
        if(cur == NULL)return;
        vec.push_back(cur->val);//根
        traversal(cur->left,vec);//左
        traversal(cur->right,vec);//右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root,result);
        return result;

    }
};

在这里插入图片描述

题目链接:https://leetcode.cn/problems/binary-tree-postorder-traversal/description/
实现情况：

/**
 * 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:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL)
            return;
        traversal(cur->left, vec);  // 左
        traversal(cur->right, vec); // 右
        vec.push_back(cur->val);    // 根
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

在这里插入图片描述

题目链接:https://leetcode.cn/problems/binary-tree-inorder-traversal/description/
实现情况：

/**
 * 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:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL)
            return;
        traversal(cur->left, vec);  // 左
        vec.push_back(cur->val);    // 根
        traversal(cur->right, vec); // 右
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

在这里插入图片描述

迭代遍历

题目链接:https://leetcode.cn/problems/binary-tree-preorder-traversal/
实现情况：

/**
 * 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:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st; //
        vector<int> result;
        if (root == NULL)
            return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top(); // 根节点先出来
            st.pop();
            result.push_back(node->val);

            if (node->right)//先放右孩子
                st.push(node->right);
            if (node->left)
                st.push(node->left);
        }
        return result;
    }
};

在这里插入图片描述

题目链接:[:https://leetcode.cn/problems/binary-tree-postorder-traversal/description/]
实现情况：

/**
 * 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:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) {
                st.push(cur);
                cur = cur->left;
            } else {
                cur = st.top();
                st.pop();
                result.push_back(cur->val);
                cur = cur->right;
            }
        }
        return result;
    }
};

在这里插入图片描述
题目链接:https://leetcode.cn/problems/binary-tree-postorder-traversal/
实现情况：

/**
 * 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:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if (root == NULL)
            return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            result.push_back(node->val); // 根节点最先进去
            if (node->left)
                st.push(node->left);

            if (node->right)
                st.push(node->right);
        }
        reverse(result.begin(), result.end()); // 翻转后输出
        return result;
    }
};

在这里插入图片描述

统一迭代

题目链接:https://leetcode.cn/problems/binary-tree-inorder-traversal/
实现情况：

/**
 * 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:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL)
            st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            if (node != NULL) {
                if (node->right) {
                    st.push(node->right);
                } // 添加右节点（空节点不入栈）

                st.push(node); // 添加中节点
                st.push(NULL); // 做标记

                if (node->left) {
                    st.push(node->left);
                } // 添加左节点（空节点不入栈）
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                node = st.top(); // 重新取出栈中元素
                st.pop();
                result.push_back(node->val); // 加入到结果集
            }
        }
        return result;
    }
};

在这里插入图片描述

题目链接:
实现情况：

/**
 * 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:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL)
            st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            if (node != NULL) {
                if (node->right) {
                    st.push(node->right);
                } // 添加右节点（空节点不入栈）

                if (node->left) {
                    st.push(node->left);
                } // 添加左节点（空节点不入栈）

                st.push(node); // 添加中节点
                st.push(NULL); // 做标记
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                node = st.top(); // 重新取出栈中元素
                st.pop();
                result.push_back(node->val); // 加入到结果集
            }
        }
        return result;
    }
};

在这里插入图片描述

题目链接:
实现情况：

/**
 * 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:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL)
            st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            if (node != NULL) {
                st.push(node); // 添加中节点
                st.push(NULL); // 做标记
                if (node->right) {
                    st.push(node->right);
                } // 添加右节点（空节点不入栈）

                if (node->left) {
                    st.push(node->left);
                } // 添加左节点（空节点不入栈）

            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                node = st.top(); // 重新取出栈中元素
                st.pop();
                result.push_back(node->val); // 加入到结果集
            }
        }
        return result;
    }
};

在这里插入图片描述

层序遍历

文章讲解:https://programmercarl.com/0102.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E5%BA%8F%E9%81%8D%E5%8E%86.html
视频讲解:https://www.bilibili.com/video/BV1GY4y1u7b2/?spm_id_from=333.788&vd_source=e70917aa6392827d1ccc8d85e19e8375

题目链接:
https://leetcode.cn/problems/maximum-depth-of-binary-tree/
给定一个二叉树 root ，返回其最大深度。
二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
实现情况：
深度:任意一个节点到根节点的距离；前序遍历
高度:根节点到叶子节点的距离；后序变量
这里使用层序遍历

/**
 * 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 == NULL)return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            depth++;//记录深度
            for(int s = 0; s <size; s++){
                TreeNode* node = que.front();//中
                que.pop();
                if(node->left){//左
                    que.push(node->left);
                }
                if(node->right){//右
                    que.push(node->right);
                }
            }
        }
        return depth;
    }
};

在这里插入图片描述

题目链接:
https://leetcode.cn/problems/minimum-depth-of-binary-tree/description/
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。

实现情况：

/**
 * 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 minDepth(TreeNode* root) {
        if (root == NULL)
            return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            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->left &&
                    !node->right) { // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                    return depth;
                }
            }
        }
        return depth;
    }

}
;

在这里插入图片描述

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

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

相关文章

ubuntu20.04安装nginx，mysql8，php7.4详细教程，包成功

ubuntu20.04安装nginx，mysql8，php7.4详细教程，包成功

目录 1.更新索引 2.安装 Nginx 1.安装 Nginx&#xff1a; 2.启动 Nginx 服务并设置为开机自启&#xff1a; 3.开放防火墙的 80 端口&#xff1a; 4.检查 Nginx 是否正常运行&#xff1a; 3.安装 MySQL 8.0 1.首先&#xff0c;安装 MySQL 的仓库&#xff1a; 安装过程中你会看…
阅读更多...
Python --Pandas库基础方法（2）

Python --Pandas库基础方法（2）

文章目录 Pandas 变量类型的转换查看各列数据类型改变数据类型 重置索引删除行索引和切片seriesDataFrame取列按行列索引选择loc与iloc获取 isin()选择query()的使用排序用索引排序使用变量值排序 修改替换变量值对应数值的替换 数据分组基于拆分进行筛选 分组汇总引用自定义函…
阅读更多...
TinyVue 组件库官网焕然一新！

TinyVue 组件库官网焕然一新！

本文由体验技术团队Kagol原创~ 之前有一些朋友吐槽我们 TinyVue 组件库的 UI 不够美观&#xff0c;于是我们请了设计师小姐姐给我们的组件和网站进行优化&#xff0c;经过设计师小姐姐和我们的开发兄弟们一个多月的努力&#xff0c;终于完成网站第一版的优化。 优化点 主要优…
阅读更多...
学习react-登录状态验证

学习react-登录状态验证

1.创建三个页面LoginPage, HomePage,NotFoundPage用于Router 创建LoginPage.tsx用于做登录页面 // LoginPage.tsx const LoginPage (props:LoginProp) > {const navigate useNavigate();return( <h1 onClick{ ()>{navigate("/");}}>Hello Login, {pr…
阅读更多...
如何在Selenium Webdriver中点击SVG元素？

如何在Selenium Webdriver中点击SVG元素？

我们将在URL上单击下面突出显示的SVG元素&#xff1a;https&#xff1a;//testkru.com/Elements/SVGelemnts。 有几种方法可以点击SVG元素&#xff0c;我们将在这篇文章中讨论它们&#xff0c;并讨论它们之间应该首选哪一种。 使用 WebElement Click() 通过使用Action Click() …
阅读更多...
前端JS特效第53集：带声音的烟花模拟绽放特效插件

前端JS特效第53集：带声音的烟花模拟绽放特效插件

带声音的烟花模拟绽放特效插件&#xff0c;先来看看效果&#xff1a; 部分核心的代码如下(全部代码在文章末尾)&#xff1a; <!DOCTYPE html> <html lang"en" > <head><meta charset"UTF-8"><title>Firework Simulator v2&…
阅读更多...
五、SpringIoC/DI的使用

五、SpringIoC/DI的使用

1. 类注解、方法注解 告诉spring管理bean—>bean的存储 1、类注解&#xff1a;五大注解 Controller&#xff08;控制器存储&#xff09;、 Service&#xff08;服务存储&#xff09;、 Repository&#xff08;仓库存储&#xff09;、 Component&#xff08;组件存储&#xf…
阅读更多...
一种多策略改进黑翅鸢智能优化算法IBKA（2024年新出优化算法）种群初始化精英反向+透镜成像反向学习+黄金正弦变异策略

一种多策略改进黑翅鸢智能优化算法IBKA（2024年新出优化算法）种群初始化精英反向+透镜成像反向学习+黄金正弦变异策略

一种多策略改进黑翅鸢智能优化算法IBKA&#xff08;2024年新出优化算法&#xff09; 种群初始化精英反向策略透镜成像反向学习策略黄金正弦变异策略 文章目录 前言一种多策略改进黑翅鸢智能优化算法IBKA&#xff08;2024年新出优化算法&#xff09; 种群初始化精英反向策略透镜…
阅读更多...
35_YOLOX网络详解

35_YOLOX网络详解

1.1 简介 YOLOX是YOLO系列&#xff08;You Only Look Once&#xff09;目标检测模型的一个最新变种&#xff0c;由阿里云团队和旷视科技在2021年提出。YOLO系列以其快速、准确的目标检测能力而闻名&#xff0c;而YOLOX在此基础上进行了多方面的改进和优化&#xff0c;旨在提供…
阅读更多...
获取手机当前信号强度（dbm/asu值）解决 getGsmSignalStrength()总是返回99问题

获取手机当前信号强度（dbm/asu值）解决 getGsmSignalStrength()总是返回99问题

能看到这篇文章说明网上哪些获取 &#xff08;dbm/asu值&#xff09;不适合你&#xff0c;不是他们的代码不正确&#xff0c;而是不符合你的情况 比如安卓6获取android手机信号强度 可以看这篇文章 https://blog.csdn.net/sinat_31057219/article/details/81134030 当然如果你…
阅读更多...
计算机三级嵌入式（三）——嵌入式系统硬件组成

计算机三级嵌入式（三）——嵌入式系统硬件组成

目录 考点1 嵌入式最小硬件系统 考点2 基于 ARM 内核的典型嵌入式应用系统硬件组成 考点3 ARM 的 AMBA 总线体系结构及标准 考点4 基于 ARM 内核的嵌入式芯片的硬件组成 考点5 存储器层次结构 考点6 存储器分类 考点7 存储器主要性能指标 考点8 片内存储器 考点9 外部…
阅读更多...
Perfectly Clear WorkBench中文绿色版，让每一张照片都完美无瑕

Perfectly Clear WorkBench中文绿色版，让每一张照片都完美无瑕

软件简介 你是否曾经为了一张不完美的照片而感到遗憾&#xff1f;是否曾经因为照片中的小瑕疵而不得不花费大量时间进行后期处理&#xff1f;现在&#xff0c;有了Perfectly Clear WorkBench&#xff0c;这些问题都将迎刃而解。作为全球领先的智能图像校正技术商推出的图像清晰…
阅读更多...
【C++高阶数据结构】红黑树：全面剖析与深度学习

【C++高阶数据结构】红黑树：全面剖析与深度学习

目录 &#x1f680; 前言&#xff1a;红黑树与AVL树的比较一&#xff1a; &#x1f525; 红黑树的概念二&#xff1a; &#x1f525; 红黑树的性质 三&#xff1a; &#x1f525; 红黑树节点的定义和结构&#x1f680; 3.1 基本元素&#x1f680; 3.2 节点颜色&#x1f680; 3.…
阅读更多...
Java中static静态变量--继承等相关知识

Java中static静态变量--继承等相关知识

目录 static 继承&#xff1a; 继承的特点&#xff1a; 案例&#xff1a;自己设计一个继承体系练习&#xff1a; 设计思想&#xff1a; 代码&#xff1a; 子类到底能继承父类的哪些类容&#xff1f; 成员变量内存的继承情况&#xff1a; 成员方法的内存继承情况&#x…
阅读更多...
项目经理的开源工具指南：优化您的选择过程

项目经理的开源工具指南：优化您的选择过程

国内外主流的10款开源项目管理系统对比&#xff1a;PingCode、Worktile、禅道、Teambition、Gogs、码云 Gitee、Jira、Redmine、ProjectLibre、OpenProject。 在选择合适的开源项目管理系统时&#xff0c;很多团队面临诸多挑战&#xff1a;功能是否全面&#xff1f;易用性如何&…
阅读更多...
C++初学（7）

C++初学（7）

7.1、字符串 字符串是存储在内存的连续字节中的一系列字符。C处理字符串的方式有两种&#xff0c;第一种是来自C语言&#xff0c;常被称为C风格字符串&#xff0c;另一种则是基于string类库的方法。 存储在连续字节中的一系列字符意味着可以将字符存储在char数组中&#xff0…
阅读更多...
Mecanim Animation System

Mecanim Animation System

动画系统简介 Unity 有一个非常丰富而又复杂的动画系统&#xff0c;官方称其为Mecanim。该系统具有以下功能&#xff1a; 支持从外部导入动画剪辑&#xff0c;如&#xff1a;fbx、mb | ma&#xff08;Autodesk maya 原件&#xff09;、.max&#xff08;3ds Max原件&#xff09…
阅读更多...
5.仓颉编程_数组使用与异常捕捉

5.仓颉编程_数组使用与异常捕捉

5.仓颉编程_数组使用与异常捕捉 数字数组与字符串数组 import std.console.*main() {var qty 10var zero2 0var array [1,2,3] //数组var str_arr:Array<String> [aa,bb]try {//qty qty / zero2//println(qty)println(str_arr[0])println(array[0])// println(arr…
阅读更多...
rhce THE homework of first

rhce THE homework of first

ssh远程免密登录成功 下载httpd和nginx 关闭防火墙 查看selinux的状态 为服务器配置ip 填充网站的内容 添加服务器配置 将文本写入网站
阅读更多...
2024电赛H题参考方案（+视频演示）——自动行使小车

2024电赛H题参考方案（+视频演示）——自动行使小车

目录 一、题目要求 二、参考资源获取 三、参考方案 1、环境搭建及工程移植 2、移植MPU6050模块 3、移植TB6612电机驱动模块 4、整体控制方案视频演示 总结 一、题目要求 小编自认为&#xff1a;此次H题属于控制类题目&#xff0c;相较于往年较为简单&#xff0c;功能也算单一&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023