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

于 2024-07-29 22:47:48 发布
阅读量512 收藏 4
点赞数 12
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43441284/article/details/140780937
版权

递归遍历

文章讲解: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;
    }

}
;

在这里插入图片描述

li星野
关注
  • 12
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
[力扣]144. 二叉树的前序遍历java
12-21
二叉树遍历是针对二叉树进行操作的一种基本算法，主要有三种类型：前序遍历、中序遍历和后序遍历。本问题主要关注的是前序遍历，它是二叉树遍历的一种常见方式。 **前序遍历**的顺序是：先访问根节点，然后递归地...
二叉树前序遍历、中序遍历、后序遍历、层序遍历的直观理解
热门推荐
白夜行的狼
05-23 38万+
0. 写在最前面 希望大家收藏： 本文持续更新地址：https://haoqchen.site/2018/05/23/go-through-binary-tree/     复习到二叉树，看到网上诸多博客文章各种绕，记得头晕。个人觉得数学、算法这些东西都是可以更直观简洁地表示，然后被记住的，并不需要靠死记硬背。 本文的程序基本来源于《大话数据结构》，个人感觉是一本非常好的书，推荐去看。 ...
二叉树遍历方法——前、中、后序遍历（图解）
在夜里行走的博客
11-04 14万+
二叉树的前、中、后序遍历的递归与非递归算法
代码随想录算法训练营第14天 | 144.二叉树前序遍历，145.二叉树后序遍历，94.二叉树中序遍历
weixin_49937617的博客
10-08 1800
递归三部曲思路需要熟练掌握
C++ 二叉树 前序遍历 中序遍历 后序遍历
weixin_40702444的博客
12-17 9427
C++ 二叉树 前序遍历 中序遍历 后序遍历 通过递归代码推出非递归实现 通过遍历规则推出非递归实现
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
主要介绍了Python二叉树的遍历操作,结合实例形式分析了Python针对二叉树的前序遍历,中序遍历,后序遍历,层序遍历等相关操作实现技巧,需要的朋友可以参考下
完全二叉树 满二叉树 二叉树遍历（前序、中序、后序）.pdf
03-12
在给定的代码中，`CreateBiTree`函数就是根据前序遍历的顺序创建二叉树的，而`PreOrderTraverse`函数则实现了前序遍历的逻辑。 2. **中序遍历**（左-根-右）：先递归地访问左子树，然后访问根节点，最后访问右子树...
二叉树的遍历，前序遍历 中序遍历 后序遍历
11-11
本文将深入探讨二叉树的三种主要遍历方法：前序遍历、中序遍历和后序遍历。 **前序遍历（Preorder Traversal）** 前序遍历的顺序是：根节点 -> 左子树 -> 右子树。这意味着我们首先访问根节点，然后递归地遍历左...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1242
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 701
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 290
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1151
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
Windows图形界面(GUI)-MFC-C/C++ - Dialog
最新发布
0xCC说逆向
07-25 1034
流程打开资源视图：在Visual Studio中，右键点击资源文件夹（通常是），选择“添加” -> “资源”。添加对话框资源：在弹出的对话框中选择“Dialog”，然后点击“新建”。设计对话框：在资源编辑器中，你可以拖放控件到对话框上，如按钮、文本框、列表框等。拓展资源ID：每个对话框都有一个唯一的资源ID，用于在代码中引用。对话框编辑器：用于可视化地设计和布局对话框。
【C++初阶】string类
2301_78022459的博客
07-24 892
【C++初阶】string类
学懂C语言（二十一）：深入理解C语言中的函数指针和回调函数
martian665的专栏
07-23 596
学懂C语言：C语言中的函数指针和回调函数详解
C++(week14): C++提高:(一)面向对象设计：设计原则、设计模式
Edward2022的博客
07-25 795
类与类之间的五种关系、面向对象的七种设计原则、23种设计模式
如何在C\#中创建HTML表格
程序员-张师傅
07-24 362
在C#中创建HTML表格通常不是直接由C#语言本身完成的，因为C#是一种面向对象的编程语言，主要用于后端逻辑处理。然而，在Web开发中，你可能会在C#代码（如在ASP.NET MVC、ASP.NET Core MVC或Razor Pages应用程序中）中生成HTML表格的字符串，或者更常见的是，使用Razor视图引擎来动态生成HTML表格。
【C#/C++】C#调C++的接口，给C++传结构体数组
一个努力写代码的小菜鸟，目前主要从事图像算法，目标检测/分割，模型量化与部署的工作
07-24 333
C#软件创建了一个结构体数组用来存储图像的区域信息，分别是矩形框的左上像素的xy坐标和矩形框右下像素的xy坐标。需要传入给调用的C++函数的参数列表中，我们选择使用C#传入一个结构体数组指针的方式，C++的参数列表中也使用数组指针来接收这个变量。首先要保证C#和C++两边定义的结构体要完全一致。
编写一个程序，实现功能具体如下：1.以二叉链表表示二叉树，建立一棵二叉树：2.输出二叉树的中序遍历结果：3.输出二叉树的前序遍历结果：4.输出二叉树的后序遍历结果：5.计算二叉树的深度；6.统计二叉树
05-29
这个程序可以分为两部分，一部分是建立二叉树，另一部分是遍历和计算。 1. 建立二叉树 以二叉链表表示二叉树，建立一棵二叉树，需要定义一个节点结构体，包含一个值域和两个指向左右子树的指针。具体的建立过程可以通过递归来实现，先输入一个值，如果值不为0，则继续输入左子树和右子树，如果值为0，则返回空节点。 2. 遍历和计算 在建立好二叉树后，可以通过递归实现三种遍历方式：前序遍历、中序遍历和后序遍历。其中，前序遍历先输出当前节点的值，再遍历左子树和右子树；中序遍历先遍历左子树，再输出当前节点的值，最后遍历右子树；后序遍历先遍历左子树和右子树，最后输出当前节点的值。 计算二叉树的深度也可以通过递归来实现，如果当前节点为空，则返回0；否则，计算左子树的深度和右子树的深度，取最大值加1即可。 统计二叉树的节点数也可以通过递归来实现，如果当前节点为空，则返回0；否则，统计左子树和右子树的节点数，并加上1。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

li星野

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值