144/94/145 二叉树的前/中/后序遍历

最新推荐文章于 2023-06-26 18:34:42 发布
最新推荐文章于 2023-06-26 18:34:42 发布
阅读量86 收藏
点赞数
分类专栏： leetcode # 树 文章标签： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45781228/article/details/119917248
版权
leetcode 同时被 2 个专栏收录
144 篇文章 1 订阅
订阅专栏
树
24 篇文章 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:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> resu;
        preorder(resu, root);
        return resu;
    }
    void preorder(vector<int>& resu, TreeNode* root){
        if(root == nullptr) return;
        resu.push_back(root->val);
        preorder(resu, root->left);
        preorder(resu, root->right);
    }
};
  • 中序遍历
/**
 * 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> resu;
        inorder(resu, root);
        return resu;
    }
    void inorder(vector<int>& resu, TreeNode* root){
        if(root == nullptr) return;
        inorder(resu,root->left);
        resu.push_back(root->val);
        inorder(resu,root->right);
    }
};
  • 后序遍历
/**
 * 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> resu;
        postorder(resu, root);
        return resu;
    }
    void postorder(vector<int>& resu, TreeNode* root){
        if(root == nullptr) return;
        postorder(resu,root->left);
        postorder(resu,root->right);
        resu.push_back(root->val);
    }
};

二、二叉树的三种遍历（迭代版）

  • 前序遍历
    • 中-左-右
    • 将根节点入栈。将根节点出栈表示访问该节点，即输出其值，再将右孩子入栈，最后将左孩子入栈。栈有后进先出的特点，此时后进的左孩子先出栈也就先被访问。
    • 不断迭代直到栈为空表示遍历完毕。
/**
 * 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> resu;//储存结果向量
        stack<TreeNode*> stk;
        if(root==NULL) return resu;
        stk.push(root);//根节点入栈，确保此时栈非空
        while(!stk.empty()){//依次处理根节点、如果左右孩子非空，就将它们入栈
            TreeNode* tmp = stk.top();
            resu.push_back(tmp->val);
            stk.pop();
            //栈为后进先出，先序遍历要先访问左孩子，就先入栈右孩子
            if(tmp->right) stk.push(tmp->right);
            if(tmp->left) stk.push(tmp->left);
        }
        return resu;
    }
};
  • 中序遍历
    • 左-中-右
    • cur指向当前访问的节点，stk.top()为当前要处理的节点
    • 先寻找整棵树最左边的节点，即如果cur有左孩子，就一直向左寻找，同时将访问过的节点入栈。当cur为空时表示已经到达了尽头，此时栈顶元素为整棵树最左边的节点，将cur指向该节点。将他出栈并将数据加入到结果向量中。此时将cur指向该节点的右孩子，如果不为空则进行寻找该节点右子树的最左边的节点。
    • 直到栈为空或cur为空表示遍历完毕
/**
 * 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> resu;
        stack<TreeNode*> stk;
        TreeNode* cur = root;
        //每次处理栈顶元素
        //cur寻找子树中最左端的节点，寻找过程中将沿途的节点入栈
        while(cur!=nullptr || !stk.empty()){
            if(cur!=nullptr){
                stk.push(cur);
                cur = cur->left;
            }else{//cur为空表示已经找到最左端的节点，此时cur的父亲节点即栈顶元素为最左端的节点
                cur = stk.top();//处理最左端的节点
                stk.pop();
                resu.push_back(cur->val);
                cur = cur->right;//处理完后寻找该节点右子树中最左端的节点
            }
        }
        return resu;
    }
};
  • 后序遍历
    • 左-右-中
    • 对先序遍历算法略做修改。调换将节点左右孩子入栈时的顺序，变成中-右-左，翻转resu向量得到左-右-中
/**
 * 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> resu;
        stack<TreeNode*> stk;
        if(root == nullptr) return resu;
        stk.push(root);
        while(!stk.empty()){
            TreeNode* tmp = stk.top();
            resu.push_back(tmp->val);
            stk.pop();
            //将先序遍历的中左右改为中右左
            if(tmp->left) stk.push(tmp->left);
            if(tmp->right) stk.push(tmp->right);
        }
        reverse(resu.begin(), resu.end());//翻转整个序列得到左右中
        return resu;
    }
};

三、二叉树的三种遍历（统一迭代版）

  • 思路
    • 解决访问节点的顺序与处理节点的顺序不一致问题（中序）
    • 解决方法：标记法，即将要处理的节点入栈后在其后入栈一个空指针。在后续的访问中如果当前栈顶为空指针，则处理接下来的节点，将其加入到结果向量中。
  • 前序遍历
/**
 * 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> resu;
        stack<TreeNode*> stk;
        if(root != NULL) stk.push(root);
        //while循环的前期在寻找节点的处理顺序，后期在按照NULL的标记处理节点
        while(!stk.empty()){
            TreeNode* cur = stk.top();//记录此时的栈顶元素
            if(cur!=NULL){//如果栈顶元素不是NULL，则继续寻找待处理节点
                stk.pop();//弹出当前节点，对该节点它的左右孩子根据遍历顺序重新入栈
                //先序遍历顺序为中左右，入栈顺序为右左中
                if(cur->right) stk.push(cur->right);
                if(cur->left) stk.push(cur->left);
                stk.push(cur);
                stk.push(NULL);//中间节点入栈后标志位入栈
            }else{//如果为NULL则表示接下来的节点为待处理的节点
                stk.pop();
                resu.push_back(stk.top()->val);
                stk.pop();
            }
        }
        return resu;
    }
};
  • 中序遍历
/**
 * 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> resu;
        stack<TreeNode*> stk;
        if(root!=NULL) stk.push(root);
        while(!stk.empty()){
            TreeNode* cur = stk.top();//记录当前栈顶节点
            if(cur!=NULL){
                stk.pop();//弹出栈顶节点，根据遍历顺序对它及左右孩子进行重新入栈
                //中序遍历为左中右，入栈顺序为右中左
                if(cur->right) stk.push(cur->right);
                stk.push(cur);
                stk.push(NULL);
                if(cur->left) stk.push(cur->left);
            }else{//处理节点
                stk.pop();
                resu.push_back(stk.top()->val);
                stk.pop();
            }
        }
        return resu;
    }
};
  • 后序遍历
/**
 * 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> resu;
        stack<TreeNode*> stk;
        if(root !=NULL) stk.push(root);
        while(!stk.empty()){
            TreeNode *cur = stk.top();//记录当前栈顶节点
            if(cur!=NULL){
                stk.pop();//弹出栈顶节点，对它及其左右孩子按照遍历顺序进行重新入栈
                //后序遍历为左右中，入栈顺序为中右左
                stk.push(cur);
                stk.push(NULL);
                if(cur->right) stk.push(cur->right);
                if(cur->left) stk.push(cur->left);
            }else{//处理节点
                stk.pop();
                resu.push_back(stk.top()->val);
                stk.pop();
            }
        }
        return resu;
    }
};

四、二叉树的三种遍历（morris版）

  • 前序遍历
/**
 * 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> resu;
        TreeNode *cur = root;//指向当前访问的节点
        while(cur!=NULL){
            if(cur->left == NULL){//如果找到最左边节点，即左链已经处理完
                resu.push_back(cur->val);
                cur = cur->right;//转向cur的父节点
            }else{//处理线索，实质是找中序遍历下的前驱
                TreeNode* node = cur->left;//node为cur的左孩子
                //查找cur左子树的最右侧节点
                while(node->right!=NULL && node->right!=cur)
                    node = node->right;
                if(node->right == NULL){//还没线索化
                    resu.push_back(cur->val);
                    node->right = cur;
                    cur = cur->left;//继续向左走
                }else{//已经线索化，则删除线索
                    node->right = NULL;
                    cur = cur->right;
                }
            }
        }
        return resu;
    }
};
  • 中序遍历
/**
 * 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> resu;
        TreeNode *cur = root;
        while(cur!=NULL){
            if(cur->left == NULL){//表示到达了最左端节点
                resu.push_back(cur->val);
                cur = cur->right;//线索化后实质为回到其父亲节点
            }else{//查找前驱，即处理线索化
                TreeNode *node = cur->left;
                //查找cur左子树的最右端节点
                while(node->right!=NULL && node->right != cur)
                    node = node->right;
                if(node->right == NULL){//还没线索化，建立线索
                    node->right = cur;
                    cur = cur->left;
                }else{//已经线索化，左子树已经访问完了，访问节点，并删除线索
                    resu.push_back(cur->val);
                    node->right = NULL;
                    cur = cur->right;
                }
            }
        }
        return resu;
    }
};
  • 后序遍历
    • 先类似前序遍历，中左右变为中右左
    • 最后翻转向量，中右左变为左右中
/**
 * 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> resu;
        TreeNode *cur = root;//指向当前访问的节点
        while(cur != NULL ){
            if(cur->right==NULL){//如果找到最右端的节点
                resu.push_back(cur->val);
                cur = cur->left;//实质为回到该节点的父亲节点
            }else{//查找前驱，实质为处理线索化
                TreeNode *node = cur->right;
                //查找cur右子树的最左端点
                while(node->left!=NULL && node->left!=cur)
                    node = node->left;
                if(node->left==NULL){//如果没有线索化
                    resu.push_back(cur->val);
                    node->left = cur;
                    cur = cur->right;//继续向右走
                }else{//如果线索化则删除线索
                    node->left = NULL;
                    cur = cur->left;/
                }
            }
        }
        reverse(resu.begin(), resu.end());//翻转向量得到左右中遍历序列
        return resu;
    }
};

二叉树的遍历迭代版参考详解

morris前序遍历参考详解

Mirevas
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 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
前中后序遍历二叉树
04-14
简单的前、中、后序遍历二叉树 部分代码:#include #include int Pos=0; typedef struct node { char data; struct node * lchild; struct node * rchild; }BTNode; BTNode* CreateTreePre(char str[]) { ...
二叉树遍历方法——前、中、后序遍历（图解）
热门推荐
在夜里行走的博客
11-04 14万+
二叉树的前、中、后序遍历的递归与非递归算法
二叉树的前序/中序/后序遍历新手入门介绍
weixin_42307601的博客
11-25 4068
本篇博客主要详细介绍：二叉树的前序/中序/后序遍历，示例并逐步详细介绍各个遍历方法的每个节点的遍历方法。
Java 二叉树后序遍历（递归/非递归）
tracy的博客
03-31 2863
Java 二叉树后序遍历（递归/非递归）
【算法】二叉树的前序遍历/中序遍历/后序遍历详解
爱学的萌萌虾
08-18 8159
这个来自leetcode的第144个问题。（中等难度） 问题描述：给定一个二叉树，返回它的 前序 遍历。 相信我们在上学期间（计算机相关专业的）已经学过二叉树，既然决定写这一篇博客，那么就从头开始复习加学习。 二叉树： 定义：二叉树是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。或者更通俗点讲： 二叉树（binary tree）是一棵树，其中每个节点都...
二叉树后序遍历
lq
06-29 2175
二叉树后序遍历 后序遍历 顺序为：左子树->右子树->跟节点 边遍历左子树，然后遍历右子树，最后遍历跟节点，以此轮推，直到遍历所有节点 6 ------------- 4 8 -------- ------- 2 5 7 9
二叉树的先序、中序、后序遍历超详解
m0_52226803的博客
05-31 9万+
以上图为基础 ①前序遍历的方式是：首先访问根节点，然后访问左子树，最后访问右子树。 前序遍历序列：F C A D B E H G M ②中序遍历的方式是：首先访问左子树，接着访问根结点，最后访问右子树。 中序遍历序列：A C B D F H E M G ③后序遍历的方式是：首先访问左子树，接着访问右子树，最后访问根结点。 后序遍历序列：A B D C H M G E F ④相同的特点： 左子树总是在右子树的之前遍历。 遍历都可以用递归的方式来描述。 中序遍历的序列中任取一个结点，该结点的左子树右子树一定分.
二叉树遍历方法——前、中、后序遍历（java）
loss_rose777的博客
06-26 4万+
前序遍历是一种访问二叉树的每一个结点的方法，它的遍历顺序是根节点，左子树，右子树。
二叉树的前中后序遍历
yanxiang3306
10-08 4623
二叉树的前中后序遍历，工欲善其事必先利其器，给大家介绍一款超牛的斩获大厂offer利器——牛客网
Java二叉树的前中后序遍历
xinhang10的博客
03-19 2244
本文章主要讲解了Java数据结构中何为二叉树的前中后序遍历，并附带了对应的题目，希望大家可以学习到二叉树的一些知识。
Java输出后序遍历二叉树的代码
最新发布
05-20
附件是Java输出后序遍历二叉树的代码，后序遍历的顺序是：首先递归地后序遍历左子树，然后递归地后序遍历右子树，最后访问根节点。 TreeNode 类定义了二叉树的节点，BinaryTree 类包含一个 root 属性和 ...
嵌入式系统/ARM技术中的关于二叉树的遍历
11-10
总结来说，二叉树的遍历是嵌入式系统/ARM技术中重要的数据结构操作，通过先序、中序和后序遍历，我们可以有效地访问和处理二叉树结构中的信息。熟练掌握这些遍历方法有助于设计和实现高效的嵌入式程序。
004 leetcode树总结
Mirevas的博客
12-04 1134
一、树的相关概念 高度与深度 节点的深度是指从根节点（深度为1）开始自顶向下逐层累加至该节点时的深度值 节点的高度是指从最底层叶子节点（高度为1）开始自底向上逐层累加至该节点时的高度值 树的深度是指树中节点的最大深度，树的高度是指树中节点的最大高度。对树而言，深度和高度是相等的。 完全二叉树 完全二叉树可以通过建立一个大小为2的k次方的数组来存放所有节点的信息，其中k为完全二叉树的最大高度 且1号位存放的必须是根节点，这样就可以用数组下标来表示节点编号 该数组中元素存放的顺序恰好为该完全二叉树的层
55跳跃游戏
Mirevas的博客
08-08 675
跳跃游戏
50 pow(x,n)
Mirevas的博客
08-04 636
pow(x,n)
46 全排列（c++ 回溯实现）
Mirevas的博客
08-03 590
全排列 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] class Solution { public: vector<vector<int>> result;//记录最终的全排列结果 vector<int> path;//记录一个全排列结果 void b...
91 解码方法
Mirevas的博客
08-19 581
91 解码方法
39组合总和 40组合总和II 216组合总和III
Mirevas的博客
11-30 493
组合总和
// 后序遍历二叉树的非递归算法
04-30
可以使用栈来实现二叉树的后序遍历。具体步骤如下： 1. 定义一个栈，将根节点压入栈中。 2. 定义一个变量 lastVisit 来记录上一次访问的节点。 3. 循环执行以下操作，直到栈为空： - 将栈顶节点出栈，如果该节点的右子树为空或者已经访问过，则访问该节点，并将 lastVisit 设置为该节点。 - 否则，将该节点再次压入栈中，并将其右子树入栈。 - 如果该节点的左子树不为空且上一次访问的节点不是该节点的左子节点和右子节点，则将其左子树入栈。 下面是 C++ 实现代码： ```cpp void postOrderTraversal(TreeNode* root) { if (root == nullptr) return; stack<TreeNode*> s; s.push(root); TreeNode* lastVisit = nullptr; while (!s.empty()) { TreeNode* node = s.top(); if ((node->right == nullptr && node->left == nullptr) || (lastVisit != nullptr && (lastVisit == node->left || lastVisit == node->right))) { cout << node->val << " "; s.pop(); lastVisit = node; } else { if (node->right) s.push(node->right); if (node->left) s.push(node->left); } } } ``` 该算法的时间复杂度为 O(n)，空间复杂度为 O(h)，其中 h 为树的高度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值