代码随想录算法训练营第十四天|144、94、145 二叉树的前序遍历、中序遍历、后序遍历（递归法和迭代法）

已于 2024-02-07 15:23:49 修改
阅读量1.2k 收藏 21
点赞数 37
分类专栏： 算法训练营31期 文章标签： 算法 数据结构 java leetcode
于 2024-02-07 14:54:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51395785/article/details/136069178
版权
本文详细介绍了二叉树的前序、中序和后序遍历，通过递归和迭代两种方法实现，并给出了Java代码示例，包括ArrayList和Stack在遍历过程中的应用。
摘要由CSDN通过智能技术生成

文章和视频讲解如下：

144、二叉树的前序遍历

/**
 * 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> result = new ArrayList<Integer>();
        preorder(root,result);
        return result;
    }
    public void preorder(TreeNode root,List<Integer> result){
        if(root == null){
            return;
        }
        result.add(root.val);
        preorder(root.left, result);
        preorder(root.right, result);
    }
}
  • 题解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> result = new ArrayList<>();
        //若传入树为空则直接返回空结果
        if(root == null){
            return result;
        }
        //辅助栈
        Stack<TreeNode> st = new Stack<>();
        //推入根结点
        st.push(root);
        //辅助栈非空，将当前栈中结点弹出同时推入当前结点的右孩子和左孩子（顺序不可变）
        while(!st.isEmpty()){
            TreeNode cur = st.pop();
            result.add(cur.val);
            if(cur.right != null){
                st.push(cur.right);
            }
            if(cur.left != null){
                st.push(cur.left);
            }
        }
        return result;
    }
}

94、二叉树的中序遍历

/**
 * 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> result = new ArrayList<Integer>();
        inorder(root, result);
        return result;
    }
    public void inorder(TreeNode root, List<Integer> result){
        if(root == null){
            return;
        }
        inorder(root.left, result);
        result.add(root.val);
        inorder(root.right,result);
    }
}
  • 题解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> result = new ArrayList<>();
        //若传入root为空栈，则返回空
        if(root == null){
            return result;
        }
        //传入非空栈(至少有根结点)
        //当前指针
        TreeNode cur = root;
        //辅助栈
        Stack<TreeNode> st = new Stack<>();
        //辅助栈非空或者当前指针未指向树最底层
        while(!st.isEmpty() || cur != null){
            //如果指针未访问到最底层
            if(cur != null){
                //入栈当前指针元素，指针处理左分支
                st.push(cur);
                cur = cur.left;
            }else{
                //若访问到最底层，转而向右处理
                cur = st.pop();
                result.add(cur.val);
                cur = cur.right;
            }
        }
        return result;
    }
}

145、二叉树的后序遍历

/**
 * 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> result = new ArrayList<Integer>();
        postorder(root, result);
        return result;
    }
    public void postorder(TreeNode root, List<Integer> result){
        if(root == null){
            return;
        }
        postorder(root.left, result);
        postorder(root.right, result);
        result.add(root.val);
    }
}
  • 题解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) {
        //后序遍历与前序相反即可
        //中-左-右  ->  中-右-左  ->  左-右-中
        //即:左右孩子入栈顺序翻转，最后把result翻转即可，其余与前序大致相同
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        Stack<TreeNode> st = new Stack<>();
        st.push(root);
        while(!st.isEmpty()){
            TreeNode cur = st.pop();
            result.add(cur.val);
            if(cur.left != null){
                st.push(cur.left);
            }
            if(cur.right != null){
                st.push(cur.right);
            }
        }
        Collections.reverse(result);
        return result;        
    }
}

相关Java语法基础：

关于Java中Collection的用法及示例：

        在Java中，Collection是一个接口，它代表一组对象，这些对象被称为元素。Collection接口提供了一系列操作元素的方法，包括添加、删除、查找和遍历等操作。

常见的Collection接口的实现类包括List、Set和Queue等，它们分别代表有序集合、无序集合和队列。

        使用Collection接口的一般步骤如下：

  1. 创建Collection对象：使用实现了Collection接口的类来创建一个集合对象，例如ArrayList、HashSet等。

  2. 添加元素：使用add()方法向集合中添加元素。

  3. 删除元素：使用remove()方法从集合中删除元素。

  4. 查找元素：使用contains()方法或者其他查找方法来查找集合中是否包含某个元素。

  5. 遍历集合：使用迭代器（Iterator）或者增强for循环来遍历集合中的元素。

        除了上述基本操作外，Collection接口还提供了其他一些常用的方法，例如size()方法用于获取集合中元素的个数，isEmpty()方法用于判断集合是否为空，clear()方法用于清空集合中的所有元素等。

        当使用Java中的Collection时，通常需要先导入java.util包。接下来是一些常见的Collection接口的用法和示例：

1、List List是一个有序集合，允许重复元素。

import java.util.List;
import java.util.ArrayList;

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");
System.out.println(list); // [Apple, Banana, Orange]

list.remove("Banana");
System.out.println(list); // [Apple, Orange]

System.out.println(list.contains("Apple")); // true

for (String fruit : list) {
    System.out.println(fruit);
}

 2、Set Set是一个不允许重复元素的无序集合。

import java.util.Set;
import java.util.HashSet;

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Orange");
System.out.println(set); // [Orange, Apple, Banana]

set.remove("Banana");
System.out.println(set); // [Orange, Apple]

System.out.println(set.contains("Apple")); // true

for (String fruit : set) {
    System.out.println(fruit);
}

 3、Map Map是一种键值对的集合。

import java.util.Map;
import java.util.HashMap;

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 10);
map.put("Banana", 20);
map.put("Orange", 15);
System.out.println(map); // {Orange=15, Apple=10, Banana=20}

map.remove("Banana");
System.out.println(map); // {Orange=15, Apple=10}

System.out.println(map.containsKey("Apple")); // true
System.out.println(map.containsValue(15)); // true

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}
         在Java中，可以使用Collections类的reverse()方法来反转List中的元素顺序。以下是使用reverse()方法的示例：
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;

public class ReverseExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");

        System.out.println("Original List: " + list); // [Apple, Banana, Orange]

        Collections.reverse(list);

        System.out.println("Reversed List: " + list); // [Orange, Banana, Apple]
    }
}

        在这个示例中，我们首先创建了一个ArrayList，并向其中添加了一些元素。然后我们使用Collections.reverse()方法来反转列表中元素的顺序。最后打印出反转后的列表，可以看到列表中的元素顺序已经被颠倒过来了。

        需要注意的是，reverse()方法只适用于List接口的实现类，而不适用于Set或者Queue。如果想对其他类型的集合进行元素顺序的反转，需要先将其转换为List类型，然后再使用reverse()方法。

 Stack定义及基础操作：

        在Java中，Stack是一种后进先出（LIFO）的数据结构，它可以存储一组元素，并且只能在栈顶进行插入和删除操作。

Stack的基础操作包括：

  1. push(element)：将元素压入栈顶。
  2. pop()：从栈顶弹出一个元素并返回。
  3. peek()：返回栈顶元素但不移除。
  4. empty()：判断栈是否为空。
  5. search(element)：查找元素在栈中的位置。

        以下是一个简单的示例代码：

import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        // 压入元素
        stack.push(1);
        stack.push(2);
        stack.push(3);

        // 弹出元素
        int element = stack.pop();
        System.out.println("弹出的元素：" + element);

        // 获取栈顶元素
        int topElement = stack.peek();
        System.out.println("栈顶元素：" + topElement);

        // 判断栈是否为空
        boolean isEmpty = stack.empty();
        System.out.println("栈是否为空：" + isEmpty);

        // 查找元素位置
        int position = stack.search(2);
        System.out.println("元素2在栈中的位置：" + position);
    }
}
ArrayList定义及基础操作：

        在Java中，ArrayList是一种动态数组，它可以存储一组元素，并且可以动态调整大小。

ArrayList的基础操作包括：

  1. add(element)：向列表末尾添加元素。
  2. add(index, element)：在指定位置插入元素。
  3. get(index)：获取指定位置的元素。
  4. remove(index)：移除指定位置的元素。
  5. size()：返回列表的大小。
  6. isEmpty()：判断列表是否为空。
  7. contains(element)：判断列表是否包含指定元素。
  8. indexOf(element)：返回指定元素在列表中的位置。

         以下是一个简单的示例代码：

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        // 向列表末尾添加元素
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");

        // 在指定位置插入元素
        list.add(1, "Grape");

        // 获取指定位置的元素
        String element = list.get(2);
        System.out.println("获取的元素：" + element);

        // 移除指定位置的元素
        list.remove(0);

        // 返回列表的大小
        int size = list.size();
        System.out.println("列表的大小：" + size);

        // 判断列表是否为空
        boolean isEmpty = list.isEmpty();
        System.out.println("列表是否为空：" + isEmpty);

        // 判断列表是否包含指定元素
        boolean contains = list.contains("Banana");
        System.out.println("列表是否包含Banana：" + contains);

        // 返回指定元素在列表中的位置
        int index = list.indexOf("Orange");
        System.out.println("Orange在列表中的位置：" + index);
    }
}
～碎冰蓝～
关注
  • 37
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java 实现的二叉树前序建树，中序建树，后序建树以及前序遍历，中序遍历和后序遍历的代码
01-20
java 实现的二叉树前序建树，中序建树，后序建树以及前序遍历，中序遍历和后序遍历的代码
C#使用前序遍历、中序遍历和后序遍历打印二叉树的方法
09-03
遍历二叉树是访问树中所有节点的过程，通常有三种基本的遍历方法：前序遍历（Preorder Traversal）、中序遍历（Inorder Traversal）和后序遍历（Postorder Traversal）。这些遍历方法在C#编程中有着广泛的应用，如...
代码随想录算法训练营第十四天|144.二叉树的前序遍历 94.二叉树的中序遍历 145.二叉树的后序遍历
滋滋牛排味的博客
05-23 280
踩坑：先看了视频，所以没踩坑，但是需要注意的是不要陷入回溯法的陷阱。
代码随想录算法训练营第14天 | 144.二叉树前序遍历，145.二叉树后序遍历，94.二叉树中序遍历
weixin_49937617的博客
10-08 1781
递归三部曲思路需要熟练掌握
代码随想录算法训练营第十四天｜144. 二叉树的前序遍历 145. 二叉树的后序遍历 94. 二叉树的中序遍历
m0_58067179的博客
06-27 163
144. 二叉树的前序遍历145. 二叉树的后序遍历94. 二叉树的中序遍历
代码随想录算法训练营第十四天|144|145|94. 二叉树的前序、中序、后序遍历
一个曾经想拯救世界，现在却连自己也拯救不了的程序员
03-05 323
给你二叉树的根节点 root ，返回它节点值的前序中序后序遍历。
代码随想录算法训练营第十四天｜144.二叉树的前序遍历、145.二叉树的后序遍历、94.二叉树的中序遍历
XiaoKeer666的博客
04-21 322
对二叉树进行前序遍历。：这个原函数要返回一个List，所以遍历的时候不用原函数，而是新创建一个返回void的preorder函数。：不断先遍历跟节点，在分别递归遍历左右节点。：O(n)：O(n)
代码随想录算法训练营第十四天|144.二叉树的前序遍历、94.二叉树的中序遍历、145.二叉树的后序遍历
qq_45518377的博客
01-23 1106
文档讲解二叉树 栈。
代码随想录算法训练营第14天|144. 二叉树的前序遍历 145. 二叉树的后序遍历 94. 二叉树的中序遍历
Catherinemin的博客
11-07 93
确定： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。确定： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。确定： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。
代码随想录算法训练营第十四天 | 144. 二叉树的前序遍历，145.二叉树的后序遍历，94.二叉树的中序遍历 [二叉树篇]
leehal的博客
02-07 593
二叉树、递归、迭代、前序遍历、中序遍历、后序遍历
代码随想录算法训练营第十四天|144. 二叉树前序遍历、 145.二叉树后序遍历、94.二叉树中序遍历
weixin_62453859的博客
07-25 82
代码随想录算法训练营第十四天|144. 二叉树前序遍历、 145.二叉树后序遍历、94.二叉树中序遍历
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
主要介绍了Python二叉树的遍历操作,结合实例形式分析了Python针对二叉树的前序遍历,中序遍历,后序遍历,层序遍历等相关操作实现技巧,需要的朋友可以参考下
算法力扣刷题记录六【203移除链表元素】
danaaaa的博客
06-21 1004
删除链表节点
排序算法系列二：归并排序、快速排序
暗黑世界
06-22 280
一、概念 二、实现 三、时间空间复杂度 四、优缺点
力扣41 缺失的正数
东篱君的博客
06-20 268
那第一个要解决的问题就是长度，这题答案其实只能在【1，length+1】中出现，因为但凡有一个位置不是这个范围内的数，那就必定有一个这个范围内的数没出现。解决了第一个长度问题，那就还有如何映射的问题，也就是我怎么知道范围里的数有没有出现过。那么最后没有变成负值的数，它对应的下标就是我们要找的范围里的数咯！这题最初的思路是用一个哈希表，将数组存入，然后从1开始找第一个哈希表中不存在的数就是缺失的正数。给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。解释：1 在数组中，但 2 没有。
代码随想录算法训练营第六天|242.有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和
最新发布
Yinems的博客
06-26 280
标答的思路改进：新建一个数组，记录s中字符出现的频率，数组的大小只需要26就行。数组是一个简单的哈希表，需要把字符映射到数组也就是哈希表的索引下标上。在遍历t的时候，对t中出现的字符映射到哈希表索引上的数值做-1操作。这道题如果用数组做，思路为统计每个数出现的频率，若某个数字出现的频率在两个数组中都大于0，则该数字属于交集。在此题中，对于元素A，我们需要找是否存在另一个元素B，使得A + B =9。nums.length = 0 意味着nums 是一个有效的数组对象，但数组中并没有任何元素。
丢失的数字（MissNumber）
2302_81707171的博客
06-23 380
丢失的数字
【算法专题--链表】旋转链表 -- 高频面试题（图文详解，小白一看就懂！！）
weixin_45031801的博客
06-26 306
旋转链表 这道题，可以说是--链表专题--，最经典的一道题，也是在面试中频率最高的一道题目，通常在面试中，面试官可能会从多个方面考察这道题目，所以大家需要对这道题目非常熟悉哦！！
二叉树 前序遍历 中序遍历 后序遍历
12-27
二叉树的前序遍历、中序遍历和后序遍历是常见的遍历方式，它们分别按照不同的顺序访问二叉树的节点。下面是它们的介绍和示例： 1. 前序遍历（Preorder Traversal）：先访问根节点，然后递归地前序遍历左子树，最后递归地前序遍历右子树。 示例代码： ```python def preorder_traversal(root): if root is None: return print(root.val) # 访问根节点 preorder_traversal(root.left) # 前序遍历左子树 preorder_traversal(root.right) # 前序遍历右子树 ``` 2. 中序遍历（Inorder Traversal）：先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。 示例代码： ```python def inorder_traversal(root): if root is None: return inorder_traversal(root.left) # 中序遍历左子树 print(root.val) # 访问根节点 inorder_traversal(root.right) # 中序遍历右子树 ``` 3. 后序遍历（Postorder Traversal）：先递归地后序遍历左子树，然后递归地后序遍历右子树，最后访问根节点。 示例代码： ```python def postorder_traversal(root): if root is None: return postorder_traversal(root.left) # 后序遍历左子树 postorder_traversal(root.right) # 后序遍历右子树 print(root.val) # 访问根节点 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值