【Leetcode054】二叉树的前序、中序和后序遍历

最新推荐文章于 2023-07-25 19:16:55 发布
最新推荐文章于 2023-07-25 19:16:55 发布
阅读量126 收藏
点赞数
分类专栏： 算法题 文章标签： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42324313/article/details/123294325
版权

文章目录

144、二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：
在这里插入图片描述
输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：
输入：root = []
输出：[]

示例 3：
输入：root = [1]
输出：[1]

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

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

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

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

提示：
树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

进阶：递归算法很简单，你可以通过迭代算法完成吗？

方法一：递归

1.1 思路分析

1.2 代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        preorder(root, res);
        return res;
    }

    public void preorder(TreeNode root, List res){
        if (root == null) return;
        res.add(root.val);
        preorder(root.left, res);
        preorder(root.right, res);
    }
}

1.3 测试结果

在这里插入图片描述

1.4 复杂度

  • 时间复杂度：O(n)，其中 n 是二叉树的节点数。每一个节点恰好被遍历一次。

  • 空间复杂度：O(n)，为递归过程中栈的开销，平均情况下为O(logn)，最坏情况下树呈现链状，为 O(n)。

方法二：迭代

2.1 思路分析

将递归中隐藏的栈显示出来。

2.2 代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
       List<Integer> res = new ArrayList<Integer>();
       if (root == null) return res;
       Deque<TreeNode> stack = new LinkedList<TreeNode>();
       TreeNode node = root;
       while( !stack.isEmpty() || node != null){
           while(node != null){
               res.add(node.val);
               stack.push(node);
               node = node.left;
           }
           node = stack.pop();
           node = node.right;
       }
       return res;
    }
}

2.3 测试结果

在这里插入图片描述

2.4 复杂度

  • 时间复杂度：O(n)，其中 n 是二叉树的节点数。每一个节点恰好被遍历一次。

  • 空间复杂度：O(n)，为迭代过程中显式栈的开销，平均情况下为 O(logn)，最坏情况下树呈现链状，为 O(n)。

145、二叉树的中序遍历

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

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

示例 2：
输入：root = []
输出：[]

示例 3：
输入：root = [1]
输出：[1]

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

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

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

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

提示：
树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

方法一：递归

1.1 思路分析

1.2 代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root, res);
        return res;
    }

    public void inorder(TreeNode root, List res){
        if (root == null) return;
        inorder(root.left, res);
        res.add(root.val);
        inorder(root.right, res);
    }
}

1.3 测试结果

在这里插入图片描述

1.4 复杂度

  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

方法二：迭代

2.1 思路分析

2.2 代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode node = root;   // 换个名字
        while(node != null || !stack.isEmpty()){
            while(node != null){
                // 将根节点和左子叶压入栈中
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            res.add(node.val);
            node = node.right;
        }
        return res;
    }
}

2.3 测试结果

在这里插入图片描述

2.4 复杂度

  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

145、二叉树的后序遍历

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

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

示例 2：
输入：root = []
输出：[]

示例 3：
输入：root = [1]
输出：[1]

提示：
树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

方法一：递归

1.1 思路分析

1.2 代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        postorder(root, res);
        return res;
    }

    public void postorder(TreeNode root, List res){
        if (root == null) return;
        postorder(root.left, res);
        postorder(root.right, res);
        res.add(root.val);
    }
}

1.3 测试结果

在这里插入图片描述

1.4 复杂度

  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

方法二：迭代

2.1 思路分析

2.2 代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */


class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode node = root;
        TreeNode prev = null;
        while(node != null || !stack.isEmpty()){
            while(node != null){
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            if (node.right == null || node.right == prev){
                res.add(node.val);
                prev = node;
                node = null;
            } else {
                stack.push(node);
                node = node.right;
            }
        }
        return res;
    }
}

2.3 测试结果

在这里插入图片描述

2.4 复杂度

  • 时间复杂度：O(n)
  • 空间复杂度：O(n)
Fly-U
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【LeetCode】【树】106. 从中序与后序遍历序列构造二叉树
12-20
从中序与后序遍历序列构造二叉树 1 题目地址 https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/ 2 题目描述 根据一棵树的中序遍历与后序遍历构造二叉树。 注意: 你...
二叉树前中后序遍历
zhanlan5211的博客
08-20 369
先序遍历 递归实现 class Solution { public List<Integer> preorderTraversal(TreeNode root) { List<Integer> res = new ArrayList<Integer>(); preorder(root, res); return res; } public void preorder(TreeNode root, L
【二叉树】利用前序和中序遍历结果生成二叉树并输出其后序和层序遍历结果
z135733的博客
07-25 2234
本设计使用的是广度优先搜索算法，并且需要输出路径，所以用到了栈和队列。根据二叉树先序和中序遍历的结果,生成该二叉树。并输出后序、层序遍历结果。
二叉树的遍历——DFS
tian__si的博客
02-23 398
先序遍历 void preorder(node* root) { if(root == NULL) return; printf("%d\n", root->data); preorder(root->lchild); preorder(root->rchild); } 中序遍历 void inorder(node* root) { if(root == NULL) return; inorder(root->lchild); printf("%d\n", root.
剑指 Offer 07. 重建二叉树 - python
javaisnotgood的博客
10-12 345
输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 例如，给出 前序遍历 preorder =[3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 思路：首先通过先序遍历序列可以得到树的根节点，然后在中序序列中找到根节点的位置，则以根节点为界限，向左到0,为左子树，向右到len() - 1 位右子树，然...
【数据结构】二叉树的前序遍历、中序遍历、后序遍历、层序遍历
m0_65679465的博客
12-15 7030
二叉树的遍历是学习二叉树首先要会的，这里从深度优先遍历（前、中、后序）和广度优先遍历（层序）两方面来详细解释如何遍历二叉树，深度优先遍历使用递归方法。
LeetCode–144,94,145,102 二叉树的前序、中序、后序、层序遍历(递归，迭代，栈，队列)
12-21
二叉树的后序遍历2.1 题目描述2.2 题目分析2.3 Python实现4. 二叉树的层序遍历2.1 题目描述2.2 题目分析2.3 Python实现 1. 二叉树的前序遍历 1.1 题目描述 难度：中等 1.2 题目分析 这道题目是二叉树相关问题的...
LeetCode_二叉树实用知识库分享
最新发布
11-10
本资源库提供了多个 LeetCode 题目的解决方案，涉及二叉树的前序遍历、中序遍历、后序遍历、层序遍历等问题，如： * 144.二叉树的前序遍历 * 94.二叉树的中序遍历 * 145.二叉树的后序遍历 * 102.二叉树的层序遍历 ...
二叉树前中后遍历（非递归）1
08-03
二叉树遍历是计算机科学中处理树结构数据时常用的一种技术，主要分为前序遍历、中序遍历和后序遍历。这三种遍历方式分别按照不同的顺序访问树中的每个节点，有助于理解和操作树的数据。在LeetCode等编程挑战平台中，...
已知二叉树前序中序遍历，建立二叉树并输出后序遍历序列（zoj1944、hdu1710）
weixin_60344133的博客
03-02 1264
介绍如何由二叉树的前序、中序遍历序列还原二叉树，并详细解析zoj1944、hdu1710
算法数据结构基础——二叉树的遍历（前序、中序、后序、层序）及python实现
白话机器学习
06-05 6745
二叉树的遍历：指的是从根节点出发，按照某种次序依次访问二叉树中所有节点，使得每个节点被访问一次且仅被访问一次。在二叉树的一些实际问题中，经常需要按照一定顺序对二叉树中每个节点逐个进行访问一次，用以查找具有某一特点的节点或者全部节点，然后对这些满足要求的节点进行处理。这里所说的「访问」就是指对该节点进行某种操作，例如：依次输出节点的数据信息、统计满足某条件的节点总数等等。回顾二叉树的递归定义可以知道，二叉树是由根节点和左子树、右子树构成的。因此，如果能依次遍历这3个部分，就可以遍历整个二叉树。
二叉树遍历方法——前、中、后序遍历（图解）
热门推荐
在夜里行走的博客
11-04 13万+
二叉树的前、中、后序遍历的递归与非递归算法
Python实现：给定二叉树的先序遍历和中序遍历结果，确定该二叉树的后序遍历结果
Ocean_waver的博客
04-22 6011
最近在学习二叉树，遇到了这样一题，在这里给大家提供一种方法，可能不是最好的，仅供大家参考和相互交流学习。 已知一个二叉树前序遍历、中序遍历的结果，请确定该二叉树并输出其后序遍历的结果。 例如: 先序遍历结果为：A B D E G C F H； 中序遍历结果为：D B G E A C H F； 则应该能够得出后序遍历结果为：D G E B H F ...
已知二叉树的前序遍历中序遍历，求二叉树的后序遍历
weixin_51979465的博客
04-22 912
已知二叉树的前序遍历中序遍历，求二叉树的后序遍历 A binary tree is a finite set of vertices that is either empty or consists of a root r and two disjoint binary trees called the left and right subtrees. There are three most important ways in which the vertices of a binary tree can
数据结构 遍历完全二叉树
m0_52336986的博客
06-06 702
遍历完全二叉树 描述 给定一棵有n（n≤1000）个元素的完全二叉树，分别对其进行先序、中序和后序遍历，输出对应的遍历序列。 例如给定完全二叉树：1 2 3 4 5 6 先序序列：1 2 4 5 3 6 中序序列：4 2 5 1 6 3 后序序列：4 5 2 6 3 1 格式 输入格式 第一行一个整数n，表示这棵完全二叉树的元素数目；第二行是n个整数，分别表示这棵二叉树上的元素值。 输出格式 输出为三行，第一行是先序遍历序列，第二行是中序遍历序列，第三行是后序遍历序列。数值之间用空格分隔 样例 输入样例 8
[二叉树建树] 复原二叉树(层序和中序)
weixin_30466421的博客
02-28 227
题目描述 给一棵二叉树的层序遍历序列和中序遍历序列，求这棵二叉树的先序遍历序列和后序遍历序列。 输入 每个输入文件中一组数据。 第一行一个正整数N（1<=N<=30），代表二叉树的结点个数（结点编号为1~N）。接下来两行，每行N个正整数，分别代表二叉树的层序遍历序列和中序遍历序列。数据保证序列中1~N的每个数出现且只出现一次。 输出 输出两行...
小明在做数据结构的作业，其中一题是给你一棵二叉树的前序遍历和中序遍历结果，要求你写出这棵二叉树的后序遍历结果。
i_m_guoguo的博客
08-16 1074
小明在做数据结构的作业，其中一题是给你一棵二叉树的前序遍历和中序遍历结果，要求你写出这棵二叉树的后序遍历结果。 输入描述 输入包含多组测试数据。每组输入包含两个字符串，分别表示二叉树的前序遍历和中序遍历结果。每个字符串由不重复的大写字母组成。 输出描述 对于每组输入，输出对应的二叉树的后续遍历结果。 输入： DBACEGF ABCDEFG BCAD CBAD 输出： ACBFGED CDAB #include <iostream> #include <queue> using nam
给定二叉树的先序遍历和中序遍历，求其后序遍历（先中定序）
whcs47的博客
03-16 2474
题目描述 Time Limit: 1000 ms Memory Limit: 256 mb 二叉树的前序、中序、后序遍历的定义： 前序遍历：对任一子树，先访问跟，然后遍历其左子树，最后遍历其右子树； 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树； 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。 给定一棵二叉树的前序遍历和中序遍历，求其后序遍历（提示：给定...
前序、中序、后序遍历的基础详解
m0_57330725的博客
11-26 3万+
在学习二叉树结构，最简单的方式就是遍历，所谓二叉树遍历是按照某种特定规则，依次对二叉树中的结点进行相应的操作，并且每个结点只操作，。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树最重要的运算之一，也是二叉树上进行其它运算的基础。 按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历： 1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。 2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之
二叉树的后序遍历c++
05-27
二叉树的后序遍历可以使用递归或者非递归的方式实现。下面是使用递归的C++代码实现： ``` void postorderTraversal(TreeNode* root) { if (root == nullptr) { return; } postorderTraversal(root->left); ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值