树的前序 中序 后序遍历 总结

最新推荐文章于 2024-09-28 19:42:39 发布
最新推荐文章于 2024-09-28 19:42:39 发布
阅读量1.1k 收藏 1
点赞数 2
文章标签： 二叉树 leetcode 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C__Try/article/details/109337445
版权

目录

树的遍历总结

遍历方式概述

二叉树的遍历分为以下三种：

  • 先序遍历：遍历顺序规则为 先遍历根节点，再遍历左子树，最后遍历右子树（根-左-右）
  • 中序遍历：遍历顺序规则为 先遍历左子树，再遍历根节点，最后遍历右子树（左-根-右）
  • 后序遍历：遍历顺序规则为 先遍历左子树，再遍历右子树，最后遍历根节点（左-右-根）

1. 先序遍历

  • 先序遍历：遍历顺序规则为 先遍历根节点，再遍历左子树，最后遍历右子树（根-左-右）
1.1 前序遍历递归写法

Leetcode 144. 二叉树的前序遍历 递归写法

/**
 * 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 dfs(TreeNode* root, vector<int> &res){
        // 如果根节点 为空，直接返回
        if(root == NULL) return ;
        // 根节点不为空，加入到遍历的数组中
        res.push_back(root->val);
        // 添加完根节点之后，遍历左节点
        dfs(root->left, res);
        // 添加完左节点之后，遍历右节点
        dfs(root->right, res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == NULL) return res;
        dfs(root, res);
        return res;
    }
};
执行结果

在这里插入图片描述

(./images/144%20result_preorderTraversal.png)]

1.2 前序遍历迭代写法1

Leetcode 144. 二叉树的前序遍历 迭代写法 1

关键代码

while(!st.empty()){
    		// 使用stack 存储右左节点 和遍历的左右顺序相反，先进后出
            TreeNode *temp = st.top();
            st.pop();
            if(!temp) continue;
            res.push_back(temp->val);
    		// 先后将 右左节点压入栈中
            if(temp->right) st.push(temp->right);
            if(temp->left) st.push(temp->left);
}

源代码

/**
 * 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> res;
        if(root == NULL) return res;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()){
            TreeNode *temp = st.top();
            st.pop();
            if(!temp) continue;
            res.push_back(temp->val);
            if(temp->right) st.push(temp->right);
            if(temp->left) st.push(temp->left);
        }
        return res;
    }

};
执行结果

在这里插入图片描述

1.3 前序遍历迭代写法2

Leetcode 144. 二叉树的前序遍历 迭代写法 2

关键代码

while(cur || !st.empty()){
    while(cur){
        st.push(cur);
        res.push_back(cur->val);
        cur=cur->left;
    }
    cur = st.top();
    st.pop();
    cur = cur->right;
}
return res;

源代码

/**
 * 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 dfs(TreeNode* root, vector<int> &res){
        // 如果根节点 为空，直接返回
        if(root == NULL) return ;
        // 根节点不为空，加入到遍历的数组中
        res.push_back(root->val);
        // 添加完根节点之后，遍历左节点
        dfs(root->left, res);
        // 添加完左节点之后，遍历右节点
        dfs(root->right, res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        // 前序遍历  根左右
        vector<int> res;
        if(root == NULL) return res;
        stack<TreeNode*> st;
        TreeNode *cur= root;
        while(cur || !st.empty()){
            while(cur){
                st.push(cur);
                res.push_back(cur->val);
                cur=cur->left;
            }
            cur = st.top();
            st.pop();
            cur = cur->right;
        }
        return res;
    }

};
执行结果

在这里插入图片描述

2. 中序遍历

  • 中序遍历：遍历顺序规则为 先遍历左子树，再遍历根节点，最后遍历右子树（左-根-右）
2.1 中序遍历递归写法

LeetCode 94. 二叉树的中序遍历 递归写法

/**
 * 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 dfs(TreeNode* root, vector<int> &res){
        // 如果根节点 为空，直接返回
        if(root == NULL){
            return ;
        }
        
        // 一直遍历 左节点  直到左节点为空，将根节点压入数组， 然后遍历右节点
        dfs(root->left, res);
        res.push_back(root->val);
        dfs(root->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == NULL) return res;
        dfs(root, res);
        return res;
    }
};
执行结果

在这里插入图片描述

2.2 中序遍历迭代写法

LeetCode 94. 二叉树的中序遍历 迭代写法

关键代码

while(cur || !st.empty()){ // 
            while(cur){  // 将根节点和所有左子树节点入栈
                st.push(cur);
                cur=cur->left;  
            }
            cur = st.top();  // 
            st.pop();
            res.push_back(cur->val);  
            cur = cur->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> res;
        if(root == NULL) return res;
        TreeNode *cur = root;
        stack<TreeNode*> st;
        
        while(cur || !st.empty()){ // 
            while(cur){  // 将根节点和所有左子树节点入栈
                st.push(cur);
                cur=cur->left;  
            }
            cur = st.top();
            st.pop();
            res.push_back(cur->val);  
            cur = cur->right;            
        }
        return res;
    }
};
执行结果

在这里插入图片描述

3. 后序遍历

  • 后序遍历：遍历顺序规则为 先遍历左子树，再遍历右子树，最后遍历根节点（左-右-根）
3.1 后序遍历递归写法

LeetCode 145. 二叉树的后序遍历 递归写法

/**
 * 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 dfs(TreeNode* root, vector<int> &res){
        if(root == NULL) return ;

        dfs(root->left, res);
        dfs(root->right, res);
        res.push_back(root->val);

    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;

        dfs(root, res);
        return res;
    }
};
执行结果

在这里插入图片描述

3.2 后序遍历迭代写法

LeetCode 145. 二叉树的后序遍历 迭代写法

后续遍历的迭代代码是最难的一个。二叉树的后续遍历时最难的一种遍历方式，因为无法判定是否遍历过右子树，所以无法判断是否访问当前节点（只有访问过右子树后才能访问父节点）。

  • 问题：如何确定当前状态是访问了左子树后过来，还是访问了右子树后来的？

  • 如果是访问左子树后过来，那么要访问右子树，如果是访问右子树后过来，那么访问当前节点

  • 我们可以根据这一特性来分辨：
    如果是访问的右子树过来，那么上次访问结果是当前的右子树，通过记录上个访问的节点，即可解决该问题。

关键代码

 while(cur || !st.empty()){
     while(cur){
         st.push(cur);
         cur= cur->left;
     }
     cur = st.top(); // get the top element of stack
     st.pop();
     if((cur->right == NULL)|| (cur->right == pre_visit)){
         pre_visit = cur;    // 记录 上一个访问的节点是哪一个
         res.push_back(cur->val);
         cur = NULL;  // 下一步就是弹栈
     }
     else{
         st.push(cur);
         cur = cur->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:
    void dfs(TreeNode* root, vector<int> &res){
        if(root == NULL) return ;
        dfs(root->left, res);
        dfs(root->right, res);
        res.push_back(root->val);

    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(!root) return res;
        stack<TreeNode*> st;
        TreeNode *cur = root;
        TreeNode * pre_visit;
        
        while(cur || !st.empty()){
            while(cur){
                st.push(cur);
                cur= cur->left;
            }
            cur = st.top(); // get the top element of stack
            st.pop();
            if((cur->right == NULL)|| (cur->right == pre_visit)){
                pre_visit = cur;    // 记录 上一个访问的节点是哪一个
                res.push_back(cur->val);
                cur = NULL;  // 下一步就是弹栈
            }
            else{
                st.push(cur);
                cur = cur->right;
            }
        }
        return res;

    }
};
执行结果

在这里插入图片描述

C__Try
关注
专栏目录
【二叉树】详解 树的遍历 (前序/中序/后序/层序) (递归+迭代)
闻韶
07-29 4208
LeetCode - 探索卡片 - 二叉树 - 一 - 树的遍历
PHP根据树的前序遍历和中序遍历构造树并输出后序遍历的方法
10-19
在这个问题中，我们探讨的是如何使用PHP来构建一棵二叉树，并根据给定的前序遍历（Preorder Traversal）和中序遍历（Inorder Traversal）序列，然后输出后序遍历（Postorder Traversal）序列。 **前序遍历**是访问...
树-树的遍历（先序、中序、后序）
热门推荐
zhazha_boring的博客
03-12 1万+
树的遍历 树的遍历方式主要分为四种，先序、中序、后序和层序，在这篇博客中我将仔细介绍一下树的这四种遍历方式。 先序遍历 先序遍历，也叫先根遍历、前序遍历，首先访问根结点然后遍历左子树，最后遍历右子树。在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树，如果二叉树为空则返回。可以简记为根左右。 以上图为例，整体的遍历过程为： 先遍历A节点 然后遍历A的左子节点B节点 接着遍历B节点的左子节点D节点 D节点没有左子节点和右子节点，然后我们回溯到B节点，遍历B节点的右子节点E节点 同理E没有
树的先（前）序遍历，中序遍历，后序遍历，层次遍历
最新发布
aqhh031115的博客
09-28 973
例如(先序遍历插入)：ABD##E##C#G##在树的数据结构中，遍历是访问树中每个节点并且仅访问一次的过程。以下是四种基本的树遍历方法，它们分别是先序遍历、中序遍历、后序遍历和层次遍历（或称为广度优先遍历）。每种遍历方法都有其特定的访问节点顺序。
树的前序中序后序遍历
leimingfu的博客
04-25 930
1.前序遍历 前序遍历是指输出当前节点，再输出左子树，最后输出右子树。 对于上图的前序遍历顺序为： 先输出1，1的左子树2存在 --> 输出2,2的左子树4存在 --> 输出4,4的左子树不存在，右子树6存在 --> 输出6,6的左子树不存在，右子树7存在 -->输出7,7的左子树不存在，右子树不存在。 此时我们观察到4的左右子树都已经遍历完（即2的左子树遍...
树——二叉树的先序、中序和后序遍历
05-26 619
1，二叉树是否只有一种遍历方式（层次遍历）？ 2，典型的二叉树的遍历方式： 1，先序遍历（Pre-Order Traversal）； 2，中序遍历（In-Order Traversal）； 3，后序遍历（Post-Order Traversal）； 3，先序遍历（“先序”指最先访问根结点中的数据元素）： 　　1，二...
树的前序遍历、中序遍历、后序遍历详解
Masterheaven的博客
05-05 1251
树的前序遍历、中序遍历、后序遍历详解 1.前序遍历 图1 对于当前节点，先输出该节点，然后输出他的左孩子，最后输出他的右孩子。以上图为例，递归的过程如下： （1）：输出 1，接着左孩子； （2）：输出 2，接着左孩子； （3）：输出 4，左孩子为空，再接着右孩子； （4）：输出 6，左孩子为空，再接着右孩子； （5）：输出 7，左右孩子都为空，此时 2 的左子树全部输出，2 的右子树为空，此时 ...
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
本文将深入探讨Python中的二叉树及其遍历方法，包括前序遍历、中序遍历、后序遍历以及层序遍历。通过具体的代码示例，我们将更好地理解这些遍历方法的工作原理和应用场景。 #### 二、二叉树基础知识回顾 二叉树是由...
树的递归、非递归前序中序后序遍历实现，层序遍历，及树的Morris前序中序后序遍历实现
03-16
树的递归、非递归前序中序后序遍历实现，层序遍历，及树的Morris前序中序后序遍历实现。main函数有测试样例，测试样例是A B D F E C G H I 。注意空出的地方是空格，前序建树。
二叉树的遍历，前序遍历 中序遍历 后序遍历
11-11
总结来说，二叉树的前序、中序和后序遍历是数据结构与算法领域中的核心概念，它们对于理解和操作二叉树至关重要。掌握这三种遍历方法不仅有助于提升编程技能，还能在解决问题时提供灵活的思路。无论是进行数据处理、...
算法--路径总和
CodersCoder的博客
09-08 709
描述 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 说明: 叶子节点是指没有子节点的节点。 示例 分析 从根节点开始，使用递归，判断左节点或者右节点到叶子节点是否存在sum-root.val即可。 实现 class Solution { public boolean hasPathSum(TreeNode root, int sum) { if (root == null) { return fa
树的先序、中序、后序遍历
微电子学与固体电子学-俞驰
09-01 568
传统算法
树的前序、中序、后序遍历
酒酿小圆子呀～
10-15 624
树的前序、中序、后序遍历 递归方法：    a  /   \ b    c   树的结构定义: struct TreeNode; typedef TreeNode* Node; typedef int EleType; struct TreeNode{ Node lchild; Node rchild; EleType data; }; (1
树的前中后序遍历
qq_39924622的博客
07-01 919
文章目录LeetCode 94.二叉树的中序遍历题目描述方法一 递归方法二 基于栈的遍历LeetCode 144.二叉树的前序遍历题目描述方法一 递归方法二 基于栈的遍历LeetCode 589.N叉树的前序遍历题目描述方法一 递归方法二 基于栈的遍历LeetCode 590.N叉树的后序遍历题目描述方法一 递归方法二 基于栈的遍历LeetCode 429.N叉树的层序遍历题目描述广度优先搜索（BFS） LeetCode 94.二叉树的中序遍历 题目描述 题目链接 给定一个二叉树，返回它的中序 遍历。 示例
树：前序遍历、中序遍历、后序遍历三者的相互求解
qq_52177557的博客
05-19 4710
刚刚又 复习 预习了一下树的遍历，也刚好再看看每两种遍历方法组合后建立树的方法；如果能建立一棵完整的树，那也就可以求出另一种遍历序列了。借这个博客刚好记录一下方法，防止以后忘了又得找文章新学一遍
深入理解树的遍历：前序遍历、中序遍历、后序遍历及层次遍历
qq_40254606的博客
07-23 1109
树（Tree）是一种常见的非线性数据结构，用于模拟具有层次关系的数据。树的遍历是树的基本操作之一，用于按一定顺序访问树中的所有节点。本文将详细介绍树的四种遍历方式：前序遍历、中序遍历、后序遍历及层次遍历。树的遍历是指按照某种规则访问树中的每个节点，并且每个节点仅访问一次。树的遍历方式主要有四种：前序遍历、中序遍历、后序遍历和层次遍历。前序遍历的顺序是：先访问根节点，再访问左子树，最后访问右子树。其递归实现如下： #mermaid-svg-dTW3Mgyl514kKdIz {font-family:"treb
树的三种遍历：前序，中序，后序
qq_45804132的博客
10-09 1万+
总体思路： 排序 定位一个元素，利用双指针游走其他元素 符合则添入答案列表，否则略过 特殊情况及细节问题 重复的元素需要略去，利用while循环和if判断语句。 若三者和小于0，则挪动指针左值右移，保持指针右值只能右移，这里注意，如果 ...
二叉树前序中序遍历推后序遍历
08-23
如果你已经得到了前序遍历（根节点 -> 左子树 -> 右子树）和中序遍历（左子树 -> 根节点 -> 右子树），想要得到后序遍历（左子树 -> 右子树 -> 根节点），可以按照以下步骤操作： 1. **前序遍历**作为线索：先序...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

C__Try

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

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

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

打赏作者

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

抵扣说明：

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

余额充值