leetcode二叉树的前中后序及思想（递归非递归）---C++实现

已于 2022-04-11 20:21:01 修改
阅读量858 收藏
点赞数
分类专栏： leetcode 文章标签： c++ 算法 leetcode 深度优先
于 2022-04-09 10:39:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eccentric_lee/article/details/124056143
版权

递归

写递归，都按照三要素来写：

  • 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
  • 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
  • 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

144.二叉树的前序遍历

leetcode 144.二叉树的前序遍历
在这里插入图片描述

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

在这里插入图片描述

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

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:
    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;
    }
};

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:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root)
        {
            st.push(root);
        }
        while(!st.empty())
        {
            TreeNode* node=st.top();
            if(node)
            {
                st.pop();

                if(node->right)    //右
                {	
                    st.push(node->right);
                }
                if(node->left)    //左
                {
                    st.push(node->left);
                }

                st.push(node);    //中
                st.push(nullptr);
            }
            else
            {
                st.pop();
                node=st.top();
                st.pop();
                result.push_back(node->val);
            }
        }

        return result;
    }
};

94. 二叉树的中序遍历

leetcode 94. 二叉树的中序遍历

题述：
给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：
在这里插入图片描述

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

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

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:
    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;
    }
};

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:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root)
        {
            st.push(root);
        }
        while(!st.empty())
        {
            TreeNode* node=st.top();
            if(node)
            {
                st.pop();
                if(node->right) //右
                {
                    st.push(node->right);
                }

                st.push(node);  //中
                st.push(nullptr);

                if(node->left)  //左
                {
                    st.push(node->left);
                }
            }
            else
            {
                st.pop();
                node=st.top();
                st.pop();
                result.push_back(node->val);
            }
        }

        return result;
    }
};

145. 二叉树的后序遍历

leetcode 145. 二叉树的后序遍历

题述：
给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例 1：

在这里插入图片描述

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

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[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:
    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;
    }
};

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:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root)
        {
            st.push(root);
        }
        while(!st.empty())
        {
            TreeNode* node=st.top();
            if(node)
            {
                st.push(nullptr);

                if(node->right)
                {
                    st.push(node->right);
                }

                if(node->left)
                {
                    st.push(node->left);
                }
            }
            else
            {
                st.pop();
                node=st.top();
                st.pop();
                result.push_back(node->val);
            }
        }

        return result;
    }
};

226. 翻转二叉树

leetcode 226. 翻转二叉树

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

示例 1：

在这里插入图片描述

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

示例 2：

在这里插入图片描述

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

示例 3：

输入：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) {
        if(root==NULL)
        {
            return NULL;
        }
        swap(root->left,root->right);
        invertTree(root->left);
        invertTree(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) {
        stack<TreeNode*> st;
        if(root)
        {
            st.push(root);
        }
        while(!st.empty())
        {
            TreeNode* node=st.top();
            if(node)
            {
                st.pop();
                if(node->right)
                {
                    st.push(node->right);
                }
                st.push(node);
                st.push(nullptr);

                if(node->left)
                {
                    st.push(node->left);
                }
            }
            else
            {
                st.pop();
                node=st.top();
                st.pop();
                swap(node->left,node->right);
            }
        }

        return root;
    }
};

589.N叉树的前序遍历

leetcode 589.N叉树的前序遍历

给定一个 n 叉树的根节点 root ，返回 其节点值的 前序遍历 。
n 叉树 在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）。

示例 1：

在这里插入图片描述

输入：root = [1,null,3,2,4,null,5,6]
输出：[1,3,5,6,2,4]

示例 2：

在这里插入图片描述

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[1,2,3,6,7,11,14,4,8,12,5,9,13,10]

栈模拟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:
    vector<int> preorder(Node* root) {
        vector<int> result;
        stack<Node*> st;

        if(root==NULL)
        {
            return result;
        }
        st.push(root);
        while(!st.empty())
        {
            Node* node=st.top();
            if(node)
            {
                st.pop();
                for(int i=node->children.size()-1;i>=0;i--)
                {
                    st.push(node->children[i]);
                }

                st.push(node);
                st.push(nullptr);
            }
            else
            {
                st.pop();
                node=st.top();
                st.pop();
                result.push_back(node->val);
            }
        }

        return result;
    }
};

590N叉树的后序遍历

leetcode 590N叉树的后序遍历

给定一个 n 叉树的根节点 root ，返回 其节点值的 后序遍历 。

n 叉树 在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）。
在这里插入图片描述

示例 1：

在这里插入图片描述

输入：root = [1,null,3,2,4,null,5,6]
输出：[5,6,3,2,4,1]

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[2,6,14,11,7,3,12,8,4,13,9,10,5,1]

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:
    vector<int> postorder(Node* root) {
        vector<int> result;
        stack<Node*> st;
        if(root==NULL)
        {
            return result;
        }
        st.push(root);
        while(!st.empty())
        {
            Node* node=st.top();
            if(node)
            {
                st.pop();
                st.push(node);
                st.push(nullptr);
                for(int i=node->children.size()-1;i>=0;i--)
                {
                    st.push(node->children[i]);
                }
                
            }
            else
            {
                st.pop();
                node=st.top();
                st.pop();
                result.push_back(node->val);
            }
        }

        return result;
    }
};

参考资料： 代码随想录

Eccentric_Lee
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
戳气球leetcode-Leetcode_notes:C++中的leetcode解决方案
06-30
前/中/后 遍历序列，构造二叉树 深搜 dfs 或者 迭代 dfs 或者 递归 都可以 二叉树深度 字典树 ：单词拆分DP思路会超时:backhand_index_pointing_right:字典树+DP 字典树里反序插入单词 路径 返回所有sum==target路径...
算法1—递归实现二叉树的前序、中序、后序遍历
龚小帅的博客
10-23 2155
仅个人理解，计算机特点就是处理速度级快，为了不遗漏、不重复处理二叉树的每一个节点，总得按照某种顺序吧，前辈们发明了处理二叉树节点的顺序：前序遍历、中序遍历、后续遍历，经过时间的检验还是可以的。二叉树的前序、中序、后序遍历的作用都是不遗漏且不重复地处理二叉树的每一个结点。
二叉树递归的思想
夏日山间过
05-09 546
/* 当遇到关于树的问题。先思考两个问题： 1.能确定一些参数，从该节点本身出发去解决问题吗 2.能够使用这些参数和节点的值确定出什么是应该传递给子节点的值吗 如果两个问题都是肯定，那么采用自顶向下的递归。 否则，如果是对于树中的任意节点，知道了子节点的结果，怎么确定出该节点的结果。就是自底向上递归的思路。 */ package primary_class; public class Test{ //自顶向下递归求二叉树的深度 public int maxDepth; public
二叉树中的递归思想
m0_62908071的博客
01-17 2068
按我的理解，递归的过程就是一个上楼梯加上下楼梯的过程（每一层台阶都是相同的，但是一级比一级高），在设计递归程序时，除了“台阶”之外，还要设计一个边界条件，在到达这个边界条件时，递归程序内部不会再向下递归（套娃），而是直接返回一个返回值，这个返回值又会成为其上一层递归的初始条件，这样就相当于开始一级一级的下楼梯。 1，前、中、后序遍历 以前序遍历为例，先访问根节点，然后是左节点，然后是右节点，并依此类推，访问全部的节点。由于在整个访问过程中的每一步，都遵循着上述的逻辑，因此这里就非常适合用递归思想来解决。
二叉树的遍历方式——前序/中序/后序/层序遍历
程序之生
11-01 343
二叉树的遍历方式 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。 层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问
429. N叉树的层序遍历 C++ 递归 DFS 与非递归写法 BFS
ZJU宁波理工
04-13 541
给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。 例如，给定一个 3叉树 : 返回其层序遍历: [ [1], [3,2,4], [5,6] ] 广度优先搜索 vector<vector<int>> levelOrder(Node* root) { vector < vector<int >> res; if (root ...
leetcode跳跃-Leetcode_Cplusplus:C++中的Leetcode解决方案
06-30
按知识点分类整理了Leetcode的一些题目，给出编程思路，提供了参考的C++实现代码。 目录 1.栈和队列 1.1-3 1.4 1.5 1.6 1.7 1.8 2.链表 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3.贪心算法 3.1 3.2 3.3 3.4 3.5 3.6 ...
leetcode 104. 二叉树的最大深度（C++）
12-22
python版——>leetcode 104：二叉树的最大深度(python) 文章目录题目层次遍历法递归法 题目 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有...
leetcode338-LeetCode:leetcodeC++实现
07-01
二叉树，指针，非递归实现 Medium 二叉树，指针，in-place，递归深入 Hard 二叉查找树(Binary Search Tree) Easy BST 构造，ref.95 Medium BST，递归解法，动归阙如 Medium BST Hard BST，space O(1) Medium BST ...
LeetCode:LeetCode问题的解决方案
03-28
LeetCode算法 算法是程序的灵魂。 算法是程序的灵魂。 ＃ 标题 解决方案 困难 种类 1753 ， 中等的 数学题 1752 ， 简单 斑点+模 1248 ， 中等的 前缀和+ hash +替换 974 ， 中等的 开头和+ hash +同余 ...
C++非递归后序遍历
coolsunxu的博客
05-30 1718
#include&lt;iostream&gt; #include&lt;stdlib.h&gt; #include&lt;stack&gt; //插入标准库中的头文件 using namespace std; typedef struct treenode { char data; treenode *rchild; treenode *lchild; }*Node; typede...
二叉树根据前序和中序推出后续
热门推荐
sowhat
04-09 2万+
根据前序跟中序 => 后序 #include #include #include using namespace std; struct BTreeNode { int _value; BTreeNode*_left; BTreeNode*_right; }; //解法一 BTreeNode* RebuildCode(int * PreStart, int *PreEn
Leetcode——二叉树的前序(第144题)、中序(94)、后序(145)、层序遍历(102)的递归和迭代写法总结
kuanyew的博客
08-22 446
Leetcode——二叉树的前序（第144题）、中序（94）、后序（145）、层序遍历（102）的递归和迭代写法总结1. 给定一个二叉树，返回它的 前序 遍历。2. 给定一个二叉树，返回它的 中序 遍历。3. 给定一个二叉树，返回它的 后序 遍历。4. 给定一个二叉树，返回它的 层序 遍历。 二叉树定义 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left;
二叉树前中后序遍历非递归实现C++
玉米味土豆片
09-30 837
前几天面试过程中面试官让手写一下二叉树后序遍历的非递归写法，当时没有写出来，本想着可能是因为面试太紧张的原因，才这么简单的题都没写出来，后来特地去研究了一下，发现二叉树的后序遍历非递归实现还真的没我想的那么简单，在此写个博客记录一下，顺便把前序和中序的非递归实现也写出来。 后序遍历非递归实现 #include <iostream> #include <stack> usi...
C++使用非递归方式实现二叉树的先序、中序、后序、层次遍历
qq_43459195的博客
03-17 886
通常遍历二叉树是用的递归办法，但是当结点数过多时很容易发生溢出现象。 学习非递归的遍历过程有利于我们更好理解遍历遵循的原理，本程序使用C++的标准模板库中的栈和队列来进行辅助。 //使用C++中的引用构建二叉树，并进行非递归遍历 #include<cstdio> #include<iostream> #include<stack> #include<queue> #include<cstdlib> using namespace std; typ
【C++】【LeetCode】【二叉树的前序、中序、后序遍历】【递归+非递归】
芊樱烛渊的博客
10-28 731
默认情况下，一个线程的栈空间大小为8MB，当递归的深度太深，我们的程序就容易崩溃如果递归的深度太深，栈空间不大，那么程序容易崩溃改成非递归1.改成循环（比方说斐波那契）2.通过栈改成循环为什么递归会空间溢出，非递归不会空间溢出？1.如果是循环的话，形成迭代，消耗的空间很可能是0（1）2.如果使用的是通过栈来改成循环的话，我们栈的开辟的空间在内存的堆区（内存中栈的空间不大，但是堆的空间很大，几乎不存在空间溢出的问题）所以这里我们将递归的遍历改成非递归。
很详细的二叉树的非递归前中后序遍历C++实现
qq_46540840的博客
04-02 330
二叉树的非递归前中后序遍历C++实现前言比如相关函数二叉树的非递归前序遍历二叉树的中序遍历->左中右中序遍历几天后更总结 前言 看到了C++ 实现代码的方便性就用c++实现一下 c++提供了现成的好多模板大大增加了代码方便性我们只用要调用相关函数就可 比如 定义栈的数据结构 只需要 stack stack1; 相关函数 有了这些函数我们就不用写相关的函数了直接用就好 size():返回栈中元素个数 top(): 返回顶元素 empty(): 判断是否为空为空则返回1 push(): 向栈
【LeetCode】—— C++实现二叉树的遍历（非递归）
chenxiyuehh的博客
03-10 419
一、二叉树的前序遍历LeetCode144题 题目描述及解析可参考博客https://blog.csdn.net/chenxiyuehh/article/details/86931798 基本思路均相同，只是实现语言不同，C++比C语言实现要简单的多，毕竟可以直接使用vector和stack，不用像C语言一样还得自己实现一个栈，也可以将遍历序列直接存入vector中，而不用像C语言一样要遍历两遍二...
二叉树的后序遍历非递归算法之c++实现
xuyongfeng的专栏
09-05 2359
#include #include using namespace std;template class TreeNode{  public:    T data;    TreeNode *left; //left child    TreeNode *right; //right child     TreeNode():left(NULL),right(NULL)    {    }   
leetcode 递归非递归
最新发布
08-16
在LeetCode中，递归和非递归都是解决问题的常见方法。递归是一种通过函数调用自身来解决问题的方法，而非递归则是使用循环或迭代来解决问题。 例如，如果我们要解决LeetCode上的"findTheWinner"问题，我们可以使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值