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

已于 2022-04-11 20:21:01 修改
阅读量942 收藏
点赞数
分类专栏： leetcode 文章标签： c++ 算法 leetcode 深度优先
于 2022-04-09 10:39:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eccentric_lee/article/details/124056143
版权
这篇博客详细介绍了如何使用递归和非递归方式实现二叉树的前序、中序、后序遍历以及N叉树的前序和后序遍历。通过C++代码展示了递归和栈模拟的方法，包括终止条件、递归逻辑以及边界情况的处理。此外，还提到了翻转二叉树的递归和非递归实现。这些算法对于理解和操作树结构的数据至关重要。
摘要由CSDN通过智能技术生成

递归

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

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

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

参考资料： 代码随想录

429. N叉树的层序遍历 C++ 递归 DFS 与非递归写法 BFS
ZJU宁波理工
04-13 582
给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。 例如，给定一个 3叉树 : 返回其层序遍历: [ [1], [3,2,4], [5,6] ] 广度优先搜索 vector<vector<int>> levelOrder(Node* root) { vector < vector<int >> res; if (root ...
二叉树非递归后序遍历的两种方法（C/C++）
weixin_42147245的博客
04-28 1501
1.镜像二叉树先序遍历结果倒置 我们可以知道，二叉树的镜像二叉树的先序遍历顺序为：根—右—左，而原二叉树的后序遍历顺序为：左—右—根。可以发现，镜像二叉树先序遍历的结果倒置过来，刚好是原二叉树的后序遍历结果，因此，可以利用如下代码实现一颗树的后序遍历： vector<int> postOrderNoRe(TreeNode* root){ } ...
Leetcode——二叉树的前序(第144题)、中序(94)、后序(145)、层序遍历(102)的递归和迭代写法总结
kuanyew的博客
08-22 562
Leetcode——二叉树的前序（第144题）、中序（94）、后序（145）、层序遍历（102）的递归和迭代写法总结1. 给定一个二叉树，返回它的 前序 遍历。2. 给定一个二叉树，返回它的 中序 遍历。3. 给定一个二叉树，返回它的 后序 遍历。4. 给定一个二叉树，返回它的 层序 遍历。 二叉树定义 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left;
二叉树的后序遍历非递归算法之c++实现
xuyongfeng的专栏
09-05 2384
#include #include using namespace std;template class TreeNode{  public:    T data;    TreeNode *left; //left child    TreeNode *right; //right child     TreeNode():left(NULL),right(NULL)    {    }   
二叉树根据前序和中序推出后续
热门推荐
sowhat
04-09 2万+
根据前序跟中序 => 后序 #include #include #include using namespace std; struct BTreeNode { int _value; BTreeNode*_left; BTreeNode*_right; }; //解法一 BTreeNode* RebuildCode(int * PreStart, int *PreEn
【C++】【LeetCode】【二叉树的前序、中序、后序遍历】【递归+非递归】
芊樱烛渊的博客
10-28 768
默认情况下，一个线程的栈空间大小为8MB，当递归的深度太深，我们的程序就容易崩溃如果递归的深度太深，栈空间不大，那么程序容易崩溃改成非递归1.改成循环（比方说斐波那契）2.通过栈改成循环为什么递归会空间溢出，非递归不会空间溢出？1.如果是循环的话，形成迭代，消耗的空间很可能是0（1）2.如果使用的是通过栈来改成循环的话，我们栈的开辟的空间在内存的堆区（内存中栈的空间不大，但是堆的空间很大，几乎不存在空间溢出的问题）所以这里我们将递归的遍历改成非递归。
C++二叉树的 前中后序遍历（学C++必看必会）深度优先遍历详解
bulangman277的博客
12-12 1726
C++二叉树的 递归 非递归 遍历方法
leetcode 二叉树-1
最新发布
02-09
比如，前中后序遍历的记忆技巧是通过记住“前中后”表示中间节点的遍历顺序。前序遍历为根-左-右，中序遍历为左-根-右，后序遍历为左-右-根。此外，深度优先遍历通常使用递归，而广度优先遍历则通常使用队列进行迭代...
leetcode-二叉树的前序、中序、后序、层序的递归和非递归实现
数据之美的博客
12-02 308
文章目录1. 二叉树的遍历2. 前序遍历2.1. 递归实现2.2. 非递归实现3. 中序遍历3.1. 递归实现3.2. 非递归实现4. 后序遍历4.1. 递归实现4.2. 非递归实现5. 层序遍历 1. 二叉树的遍历 面试中，尤其是校招面试中（哈哈，社招面试估计是嫌这种题目太简答，不屑于考察），经常被问到的一个题目就是二叉树的各种遍历算法，而我们常见的二叉树的遍历方式有前序遍历、中序遍历、后序遍历...
LeetCode---C++实现
07-21
《LeetCode---C++实现》是一本专注于C++编程语言解决LeetCode在线判题平台上的算法问题的书籍。LeetCode是程序员广泛使用的平台，它提供了大量的编程题目来提升编程技能和算法理解，尤其对于准备面试的程序员来说，...
C++非递归后序遍历
coolsunxu的博客
05-30 1761
#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...
很详细的二叉树的非递归前中后序遍历C++实现
qq_46540840的博客
04-02 453
二叉树的非递归前中后序遍历C++实现前言比如相关函数二叉树的非递归前序遍历二叉树的中序遍历->左中右中序遍历几天后更总结 前言 看到了C++ 实现代码的方便性就用c++实现一下 c++提供了现成的好多模板大大增加了代码方便性我们只用要调用相关函数就可 比如 定义栈的数据结构 只需要 stack stack1; 相关函数 有了这些函数我们就不用写相关的函数了直接用就好 size():返回栈中元素个数 top(): 返回顶元素 empty(): 判断是否为空为空则返回1 push(): 向栈
二叉树的遍历方式——前序/中序/后序/层序遍历
程序之生
11-01 405
二叉树的遍历方式 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。 层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问
二叉树递归的思想
夏日山间过
05-09 607
/* 当遇到关于树的问题。先思考两个问题： 1.能确定一些参数，从该节点本身出发去解决问题吗 2.能够使用这些参数和节点的值确定出什么是应该传递给子节点的值吗 如果两个问题都是肯定，那么采用自顶向下的递归。 否则，如果是对于树中的任意节点，知道了子节点的结果，怎么确定出该节点的结果。就是自底向上递归的思路。 */ package primary_class; public class Test{ //自顶向下递归求二叉树的深度 public int maxDepth; public
算法1—递归实现二叉树的前序、中序、后序遍历
龚小帅的博客
10-23 2395
仅个人理解，计算机特点就是处理速度级快，为了不遗漏、不重复处理二叉树的每一个节点，总得按照某种顺序吧，前辈们发明了处理二叉树节点的顺序：前序遍历、中序遍历、后续遍历，经过时间的检验还是可以的。二叉树的前序、中序、后序遍历的作用都是不遗漏且不重复地处理二叉树的每一个结点。
[LeetCode总结]二叉树-前中后序-非递归写法
星空的博客
08-01 210
神评 [★★★★☆] 一套带走 作者：sonp orz 链接：https://leetcode-cn.com/problems/binary-tree-postorder-traversal/solution/mo-fang-di-gui-zhi-bian-yi-xing-by-sonp/ 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 vector<int> preorderTraversal(TreeNode* root) {
详细图解二叉树中序遍历（非递归C++）LeetCode94
m0_55864612的博客
09-27 2640
详细图解二叉树中序遍历（非递归）二叉树中序递归含义LeetCode题目94详细图解源代码运行结果 二叉树中序递归含义 中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。若二叉树为空则结束返回，否则： （1）中序遍历左子树 （2）访问根结点 （3）中序遍历右子树 如图1所示二叉树，中序遍历结果：DBEAFC LeetCode题目94 给定一个二叉树的根节点 root ，返回它的 中序 遍历。 输入：root = [1,null,2,3] 输出：[1,3,2] 输入：root = [1,2] 输出：
二叉树中的递归思想
m0_62908071的博客
01-17 2196
按我的理解，递归的过程就是一个上楼梯加上下楼梯的过程（每一层台阶都是相同的，但是一级比一级高），在设计递归程序时，除了“台阶”之外，还要设计一个边界条件，在到达这个边界条件时，递归程序内部不会再向下递归（套娃），而是直接返回一个返回值，这个返回值又会成为其上一层递归的初始条件，这样就相当于开始一级一级的下楼梯。 1，前、中、后序遍历 以前序遍历为例，先访问根节点，然后是左节点，然后是右节点，并依此类推，访问全部的节点。由于在整个访问过程中的每一步，都遵循着上述的逻辑，因此这里就非常适合用递归思想来解决。
二叉树前中后序递归及非递归遍历C++实现完整版
tomato_guo的博客
08-08 1045
给定一个二叉树，返回它的前中后序遍历。 示例：输入[1,2,3,4,-1,5,6,-1,7,-1,-1,8,-1] ,-1代表无节点(null)，二叉树如下所示： 输出：二叉树的前序、中序、后序遍历序列。 完整实现代码（包括定义数据结构、建树等）如下： #include<iostream> #include<string> #include<vector...
二叉树前中后序遍历非递归实现C++
玉米味土豆片
09-30 884
前几天面试过程中面试官让手写一下二叉树后序遍历的非递归写法，当时没有写出来，本想着可能是因为面试太紧张的原因，才这么简单的题都没写出来，后来特地去研究了一下，发现二叉树的后序遍历非递归实现还真的没我想的那么简单，在此写个博客记录一下，顺便把前序和中序的非递归实现也写出来。 后序遍历非递归实现 #include <iostream> #include <stack> usi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值