每日一恋 - LeetCode 144 & 94 & 145. 二叉树的前序遍历、中序遍历、后序遍历

最新推荐文章于 2022-03-19 21:44:26 发布
最新推荐文章于 2022-03-19 21:44:26 发布
阅读量206 收藏
点赞数 1
分类专栏： LeetCode 每日一恋 文章标签： LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smartnijun/article/details/81805283
版权

前言

实现二叉树的前序（preorder）、中序（inorder）、后序（postorder）遍历有两个常用的方法：一是递归(recursive)，二是使用栈实现的迭代版本(stack+iterative)。这两种方法都是O(n)的空间复杂度（递归本身占用stack空间或者用户自定义的stack）。第三种是Morris方法遍历，它的空间复杂度只有O(1)。

复杂度分析：

  1. Recursive solution. Time: O(n), Space: O(n).
  2. Iterative way (stack). Time: O(n), Space: O(n).
  3. Threaded tree (Morris). Time: O(n), Space: O(1).

144. 二叉树的前序遍历

解法一

迭代版，用栈存放遍历的节点，注意是按照访问节点，压入右节点，压入左节点的顺序。

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> list = new ArrayList<Integer>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        list.add(node.val);
        if (node.right != null) stack.push(node.right);
        if (node.left != null) stack.push(node.left);
    }
    return list;
}

解法二

迭代版，将节点全部压入栈中，再弹出。

步骤：

  1. 当前节点不为空，入栈并输出当前节点，将其左孩子作为当前节点。
  2. 当前节点为空，栈中不为空，弹出一个节点，将其右孩子作为当前节点。
  3. 重复1、2直到栈为空，当前节点为空时结束循环。
public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> list = new ArrayList<Integer>();
    if (root == null)
        return list;

    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode p = root;
    while (!stack.isEmpty() || p != null) {
        while (p != null) {
            stack.push(p);
            list.add(p.val);
            p = p.left;
        }
        p = stack.pop();
        p = p.right;
    }
    return list;
}

或者

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode p = root;
    while(!stack.isEmpty() || p != null) {
        if(p != null) {
            stack.push(p);
            result.add(p.val);  
            p = p.left;
        } else {
            TreeNode node = stack.pop();
            p = node.right;
        }
    }
    return result;
}

解法三

迭代版，也使用栈进行储存，但是栈里只存放右节点。每当到达一个节点时，右节点不为空先将右节点压入栈中；然后访问左节点，判断左节点是否为 null，如果为 null，并且栈不为空的话，就弹出之前存放的右子节点继续遍历。如果用示意图来表达的话，就是访问指针每次都先往左子节点遍历，直到为null，然后取出其父节点的右子树继续向左子节点遍历，以此类推。

步骤：

  1. 当前节点不为空，输出当前节点。
  2. 如果当前节点的右孩子不为空，向栈中压入右孩子。将其左孩子作为当前节点。
  3. 如果当前节点为空，但栈不为空，继续从栈中弹出一个节点作为当前节点。

代码：

public List<Integer> preorderTraversal(TreeNode node) {
    List<Integer> list = new LinkedList<Integer>();
    Stack<TreeNode> rights = new Stack<TreeNode>();
    while (node != null) {
        list.add(node.val);
        if (node.right != null) {
            rights.push(node.right);
        }
        node = node.left;
        if (node == null && !rights.isEmpty()) {
            node = rights.pop();
        }
    }
    return list;
}

解法四

Morris Traversal方法遍历二叉树（非递归，不用栈，O(1)空间），它能实现：

  1. O(1)空间复杂度，即只能使用常数空间；
  2. 二叉树的形状不能被破坏（中间过程允许改变其形状）。

Morris Traversal方法可以做到这两点，与递归和栈实现的不同在于该方法只需要O(1)空间，而且同样可以在O(n)时间内完成。具体可以参看(http://www.cnblogs.com/AnnieKim/archive/2013/06/15/morristraversal.html)

主要步骤：

  1. 如果当前节点的左孩子为空，则输出当前节点并将其右孩子作为当前节点。
  2. 如果当前节点的左孩子不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点。
    a) 如果前驱节点的右孩子为空，将它的右孩子设置为当前节点。输出当前节点（在这里输出，这是与中序遍历唯一一点不同）。当前节点更新为当前节点的左孩子。
    b) 如果前驱节点的右孩子为当前节点，将它的右孩子重新设为空。当前节点更新为当前节点的右孩子。
  3. 重复以上1、2直到当前节点为空。

图示：
这里写图片描述

代码：

public void preorderMorrisTraversal(TreeNode root) {
    TreeNode cur = root, prev = null;
    while (cur != null) {
        if (cur.left == null) {
            System.out.println(cur.val);
            cur = cur.right;
        }
        else {
            prev = cur.left;
            while (prev.right != null && prev.right != cur)
                prev = prev.right;

            if (prev.right == null) {
                System.out.println(cur.val);
                prev.right = cur;
                cur = cur.left;
            }
            else {
                prev.right = null;
                cur = cur.right;
            }
        }
    }
}

解法五

递归版本

public List<Integer> preorderTraversal(TreeNode node) {
    List<Integer> list = new ArrayList<Integer>();
    dfs(node, list);
    return list;
}

public void dfs(TreeNode node, List<Integer> list) {
    if (node == null)
        return;
    list.add(node.val);
    dfs(node.left, list);
    dfs(node.right, list);
}

94. 二叉树的中序遍历

解法一

与前序遍历同样是先遍历左子节点再遍历右子节点，不同之处在于：前序遍历的实现方式是在压入栈的时候就访问了这个节点，而中序遍历的实现方式是从栈中弹出节点之后进行访问，保存其顺序。

先遍历当前节点的左子节点，直到没有左子节点，然后pop出当前最后一个左子节点，访问之，再遍历其右子节点的左子节点，以此类推。如果遍历到某个节点为空，那继续pop出下一个节点。

public List<Integer> inorderTraversal(TreeNode root) {

    List<Integer> list = new ArrayList<Integer>();
    if (root == null)
        return list;

    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode p = root;
    while ( !stack.isEmpty() || p != null ) {
        while (p != null) {
            stack.push(p);
            p = p.left;
        }
        p = stack.pop();
        list.add(p.val);
        p = p.right;
    }
    return list;
}

或者 

public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode p = root;
    while(!stack.isEmpty() || p != null) {
        if(p != null) {
            stack.push(p);
            p = p.left;
        } else {
            TreeNode node = stack.pop();
            result.add(node.val);  
            p = node.right;   
        }
    }
    return result;
}

解法二

Morris Traversal中序遍历，非递归。

步骤：

  1. 如果当前节点的左孩子为空，则输出当前节点并将其右孩子作为当前节点。
  2. 如果当前节点的左孩子不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点。
    a) 如果前驱节点的右孩子为空，将它的右孩子设置为当前节点。当前节点更新为当前节点的左孩子。
    b) 如果前驱节点的右孩子为当前节点，将它的右孩子重新设为空（恢复树的形状）。输出当前节点。当前节点更新为当前节点的右孩子。
  3. 重复以上1、2直到当前节点为空。

图示：
下图为每一步迭代的结果（从左至右，从上到下），cur代表当前节点，深色节点表示该节点已输出。
这里写图片描述

代码：

public void inorderMorrisTraversal(TreeNode root) {
    TreeNode cur = root, prev = null;
    while (cur != null) {
        if (cur.left == null) {
            System.out.println(cur.val);
            cur = cur.right;
        }
        else {
            prev = cur.left;
            while (prev.right != null && prev.right != cur)
                prev = prev.right;

            if (prev.right == null) {
                prev.right = cur;
                cur = cur.left;
            }
            else {
                prev.right = null;
                System.out.println(cur.val);
                cur = cur.right;
            }
        }
    }
}

O(1)空间复杂度
O(n)时间复杂度

空间复杂度：O(1)，因为只用了两个辅助指针。
时间复杂度：O(n)。证明时间复杂度为O(n)，最大的疑惑在于寻找中序遍历下二叉树中所有节点的前驱节点的时间复杂度是多少，即以下两行代码：

while (prev->right != NULL && prev->right != cur)
    prev = prev->right;

直觉上，认为它的复杂度是O(nlgn)，因为找单个节点的前驱节点与树的高度有关。但事实上，寻找所有节点的前驱节点只需要O(n)时间。n个节点的二叉树中一共有n-1条边，整个过程中每条边最多只走2次，一次是为了定位到某个节点，另一次是为了寻找上面某个节点的前驱节点，如下图所示，其中红色是为了定位到某个节点，黑色线是为了找到前驱节点。所以复杂度为O(n)。

这里写图片描述

解法三

递归版，参数传递结果。

public List<Integer> inorderTraversal(TreeNode node) {
    List<Integer> list = new ArrayList<Integer>();
    dfs(node, list);
    return list;
}

public void dfs(TreeNode node, List<Integer> list) {
    if (node == null)
        return;
    dfs(node.left, list);
    list.add(node.val);
    dfs(node.right, list);
}

解法四

递归版，返回值作为结果。

public List<Integer> inorderTraversal(TreeNode root) {

    List<Integer> list = new ArrayList<Integer>();

    if (root == null)
        return list;

    List<Integer> left = inorderTraversal(root.left);
    if (left != null) list.addAll(left);
    list.add(root.val);
    List<Integer> right = inorderTraversal(root.right);
    if (right != null) list.addAll(right);
    return list;
}

145. 二叉树的后序遍历

解法一

与前序遍历的解法一类似，前序遍历每次先压入右孩子然后再左孩子（访问顺序先左后右），后序遍历正好相反，压入栈时先左后右（访问顺序先右后左）。后序遍历从根节点开始，越早遍历的节点越晚打印，因此需要后入先出的数据结构来保存结果，实际上队列和栈都可以。

public List<Integer> postorderTraversal(TreeNode root) {
    LinkedList<Integer> list = new LinkedList<>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        list.addFirst(node.val);
        if (node.left != null) stack.push(node.left);
        if (node.right != null) stack.push(node.right);
    }
    return list;
}

解法二

与前序遍历的解法二类似。关键在于倒序输出，先访问右孩子再访问左孩子。

public List<Integer> postorderTraversal(TreeNode root) {

    LinkedList<Integer> list = new LinkedList<Integer>();
    if (root == null)
        return list;

    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode p = root;
    while ( !stack.isEmpty() || p != null ) {
        while (p != null) {
            stack.push(p);
            list.addFirst(p.val);
            p = p.right;
        }
        p = stack.pop();
        p = p.left;
    }
    return list;
}

或者 

public List<Integer> postorderTraversal(TreeNode root) {
    LinkedList<Integer> result = new LinkedList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode p = root;
    while(!stack.isEmpty() || p != null) {
        if(p != null) {
            stack.push(p);
            result.addFirst(p.val);  
            p = p.right;             
        } else {
            TreeNode node = stack.pop();
            p = node.left;           
        }
    }
    return result;
}

关于层序遍历请看每日一恋 - LeetCode 102 & 107. 二叉树的层次遍历

本文是我参考了网上的资料和加上自己的理解总结的，如果有什么不对的地方非常欢迎大家的指正。

参考：
http://www.cnblogs.com/AnnieKim/archive/2013/06/15/morristraversal.html
https://www.yunaitong.cn/binary-tree-traverse.html

love4rui
关注
专栏目录
二叉树的遍历（leetcode）
qq_36136459的博客
03-18 422
关于二叉树的遍历有递归和非递归两种方法，记得递归的方法是在考研的时候看着王道书学的。递归的办法非常的简单，在这里就不不再多说了。下面就来讲讲非递归的办法。 先序遍历：先序遍历下面的二叉树：ABCDEFGH。想必这个大家都能很简单的想出来。 算法步骤： 1.首先创建一个动态数组(ArrayList)来保存要输出的序列，因为动态数组初始化时不用告诉数组的长度，可以动态添加元素。 2.接...
二叉树前序遍历、中序遍历、后序遍历、层序遍历简单理解，秒懂
qq_49425839的博客
03-19 903
文章开始前，说一句废话：希望大家对所学能认真好好理解，那样才能自己的东西，理解万岁！ 能到这里我相信大家最少知道二叉树是什么东西了吧，那我们直奔主题； 前序遍历，中序遍历，后序遍历，层序遍历到底是什么 一棵二叉树由根结点、左子树和右子树三部分组成，若规定 D、L、R 分别代表遍历根结点、遍历左子树、遍历右子树，我们开始讨论最常见的三种遍历方式 DLR--前序遍历（根在前，从左往右，一棵树的根永远在左子树前面，左子树又永远在右子树前面 ） LDR--中序遍历（根在中，从左往右，一棵树的左子树永远在根.
【算法之LeetCode系列（7）】—— 二叉树的遍历
summer爱前端
10-26 315
一篇文章，带你砍掉所有的二叉树（的遍历）
leetcode | 二叉树的前序遍历、中序遍历、后续遍历的非递归实现
quinn的专栏
06-01 3241
Binary Tree Preorder Traversal：https://leetcode.com/problems/binary-tree-preorder-traversal/ Binary Tree Inorder Traversal ：https://leetcode.com/problems/binary-tree-inorder-traversal/ Binary Tree Po
【leetcode二叉树——二叉树遍历】
qq_32863265的博客
06-21 552
题目序号1. leetcode144 二叉树的前序遍历2. leetcode94 二叉树的中序遍历3. leetcode145 二叉树的后序遍历4. leetcode102 二叉树的层序遍历5. leetcode107 二叉树的层序遍历II6. leetcode104 二叉树的最大深度7. leetcode543 二叉树的直径8. leetcode110 平衡二叉树9. leetcode111 二叉树的最小深度 1. leetcode144 二叉树的前序遍历 2. leetcode94 二叉树的中序遍历 3
二叉树的后序遍历 leetcode
06-13 1123
题目：给定一个二叉树，返回它的 后序 遍历。方法包括递归法和迭代法，递归法较为简单，此处给出迭代法。思路：一路向左，直达最左端的左结点，扔到栈内。然后根据判断语句弹出栈内的左结点。栈内的结点如果是有右子树的结点，就要把该结点的右子树指针标为NULL，然后压到栈内。（这个的意义在于，不能先访问根节点，所以要押回去，把右指针置为NULL是为了表示该结点的右子树是被访问过了，等下回来的时候可以直接输出这...
LeetCode–144,94,145,102 二叉树的前序、中序、后序、层序遍历(递归，迭代，栈，队列)
12-21
在LeetCode的题目144, 94, 145, 102中，分别考察了这四种遍历方式。通过递归和迭代两种方法，我们可以有效地遍历二叉树。递归方法直观且易于理解，而迭代方法通常更适用于处理大规模数据或避免栈溢出的问题。对于...
php-leetcode题解之二叉树的中序遍历.zip
最新发布
06-08
中序遍历是二叉树遍历的三种基本方法之一，对于理解数据结构和算法至关重要。 首先，我们来详细解释二叉树的基本概念。二叉树是一种非线性数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。这种...
前序遍历，中序遍历，后序遍历是如何还原一棵二叉树的？
ifwecande的博客
06-22 1410
文章目录前序遍历和中序遍历还原二叉树思路（迭代）代码前序遍历和中序遍历还原二叉树思路代码 二叉树的前中后三种遍历方式，各有各的特点。 我们可以通过前中后三种遍历方式中两种遍历方式的组合去还原一棵二叉树。 (无重复元素的树) 注意： 我们只能通过前中，中后两种方式去还原一棵确定的二叉树。 原因： 以前序遍历和中序遍历为例。 前序遍历是通过根左右的方式进行访问的，中序遍历时通过左根右的方式进行遍历的。 显而易见，前序遍历区分出根和左右节点，中序遍历区分出左节点和右节点，如此一来，根和左右节点的顺序一目了然，我们
asshead123#my-leetcode#二叉树-105. 从前序与中序遍历序列构造二叉树1
07-25
前序遍历中第一个节点一定是根节点，只要在中序遍历中定位到根节点，那么就可以分别知道左子树和右子树中的节点数目。由于同一颗子树的前序遍历和中序遍历的长度显然是相同
Leetcode之二叉树遍历总结
Fred_18的博客
08-31 293
一直想把二叉树的各种遍历做一个总结，在掌握好二叉树的4中遍历的基础上，其他的题目自然迎刃而解(可能有点夸张)。前、中、后序有递归和非递归的写法，一定要掌握，至于层序遍历嘛，直接非递归怼就是(基础概念不赘述)。 1. 前序遍历 Leetcode 144. Binary Tree Preorder Traversal /** * Definition for a binary tree node...
二叉树（前序、中序、后序遍历图片步骤详解）
热门推荐
念念不忘，必有回响
06-08 6万+
首先我们有这么一颗二叉树： 前序遍历：根结点 —> 左子树 —> 右子树 这棵树的前序遍历为：ABDEGHCF 中序遍历：左子树—> 根结点 —> 右子树 这棵树的前序遍历为：DBGEHACF 后序遍历：左子树 —> 右子树 —> 根结点 这棵树的前序遍历为：DGHEBFCA 层次遍历：按层次遍历 这棵树的前序遍历为：ABCDEF...
Leetcode 145:二叉树的后序遍历（最详细的解法！！！）
coordinate的博客
07-14 2789
给定一个二叉树，返回它的 后序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [3,2,1] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ 解题思路 这是一个基础问题，我们参考之前的两个问题 Leetcode 144:二叉树的前序遍历（最详细解决方案！！！） Leetcode 94:二叉树的中序...
LeetCode 二叉树的层次遍历
hestyle的博客
02-19 8520
给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。 例如: 给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层次遍历结果： [ [3], [9,20], [15,7] ] 二叉树层次遍历：按照二叉树的层次，从根节点所在的层，逐层进行遍历。逐层遍历时按照从...
Leetcode 二叉树四种遍历方式总结
moonspiritacm
08-19 908
文章目录1. 前序遍历2. 中序遍历3. 后序遍历4. 层序遍历 1. 前序遍历 Leetcode 144. 二叉树的前序遍历 递归实现： class Solution { public List<Integer> preorderTraversal(TreeNode root) { List<Integer> res = new ArrayList...
leetcode树之二叉树遍历
溪语流沙的博客
03-19 574
树 看到标题，你是否会想到现实世界中的树，不过此树非彼树，树是一种数据结构，在展示上类似于倒放的树，如果你实在想不到倒放的树，你可以想象一下树根。树在某种意义上，可以看做是链表的升级版。 链表的定义： class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next 而看一下树的定义： class TreeNode: def __init__(self, val=0, chil
Leetcode 树的遍历
Molly
12-28 757
1、Same Tree 链接：https://leetcode.com/problems/same-tree/ 思路：递归思想 public boolean isSameTree(TreeNode p, TreeNode q) { if(p == null && q == null) return true; if((p == nul
Leetcode中二叉树问题汇总（一）
wolvvi的博客
08-29 1363
最近陆陆续续在刷树结构这类的问题，非线性结构的问题一直是软肋，尤其是这类问题大量使用递归，对于我这种混了好几年的小白来说不容易理解，因此针对Leetcode中树这一类问题进行了下总结，温故而知新嘛（之前学的都还给老师了…），同时也希望各位大神批评指正。 篇幅有限，本文先写二叉树的一些基本操作。 二叉树的概念 二叉树的基本概念具体可以参考：度娘带你走进二叉树 抽取其中主要的做个简单的介绍...
每日一恋 - LeetCode 147 & 148. 对链表进行排序
love4rui的博客
08-17 1304
147. 对链表进行插入排序 插入排序的动画演示如上。从第一个元素开始，该链表可以被认为已经部分排序（用黑色表示）。 每次迭代时，从输入数据中移除一个元素（用红色表示），并原地将其插入到已排好序的链表中。 插入排序算法： 插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。 每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，...
C语言解决LeetCode第144题：二叉树前序遍历详解
针对LeetCode第144题“二叉树的前序遍历”的C语言题解，需要实现一个函数，输入为二叉树的根节点，输出为一个数组或列表，包含按前序遍历顺序的节点值。题解分析将帮助读者理解如何构建二叉树结构，如何遍历二叉树并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值