Java常见算法（四）【二叉树遍历：递归、迭代（模拟递归）】

最新推荐文章于 2023-04-14 19:32:34 发布
最新推荐文章于 2023-04-14 19:32:34 发布
阅读量669 收藏
点赞数
分类专栏： 算法 java 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YL3126/article/details/121414082
版权
java 同时被 2 个专栏收录
86 篇文章 4 订阅
订阅专栏
算法
8 篇文章 2 订阅
订阅专栏

文章目录

二叉树遍历

https://www.bilibili.com/video/BV1Jv411A7Ty?p=22
在这里插入图片描述

1、前序遍历-递归

https://www.bilibili.com/video/BV1Jv411A7Ty?p=23

前序、中序、后续遍历其实就是一直打印栈顶，但是打印的时机有所不同；

前序遍历是第一次成为栈顶就打印。
在这里插入图片描述
在这里插入图片描述

 //1、前序-递归
    public static void preorder(TreeNode root){
        if(root==null){
            return;
        }
        System.out.println(root.val);//(第一次成为栈顶才打印)
        preorder(root.left);
        preorder(root.right);
    }

结果：

1
2
4
5
6
7
3

2、中序遍历-递归

https://www.bilibili.com/video/BV1Jv411A7Ty?p=24

前序、中序、后续遍历其实就是一直打印栈顶，但是打印的时机有所不同；

中序遍历是第二次成为栈顶才打印。
在这里插入图片描述
在这里插入图片描述

 //1、中序-递归(第二次成为栈顶才打印)
    public static void preorder1(TreeNode root){
        if(root==null){
            return;
        }
        
        preorder1(root.left);
        System.out.println(root.val);//(第二次成为栈顶时进行打印)
        preorder1(root.right);
    }

结果：

4
2
6
5
7
1
3

3、后序遍历-递归

https://www.bilibili.com/video/BV1Jv411A7Ty?p=25

前序、中序、后续遍历其实就是一直打印栈顶，但是打印的时机有所不同；

后序遍历是第三次成为栈顶才打印。
在这里插入图片描述
在这里插入图片描述

 //1、后序-递归(第三次成为栈顶才打印)
    public static void preorder2(TreeNode root){
        if(root==null){
            return;
        }
        preorder2(root.left);
        preorder2(root.right);
        System.out.println(root.val);//(第三次成为栈顶时进行打印)
    }

结果：

2
4
5
6
7
3
1

4、层序遍历-递归

在这里插入图片描述

//4、层序遍历
    public static void levelOrder(TreeNode root,int i, ArrayList list){
        if(root==null){
            return;
        }
        //为了防止数组越界，需要进行数组容量填充
        int lenght=list.size();
        if(lenght<=i){
            for (int j=0;j<=i-lenght;j++){
                list.add(lenght+j,null);
            }
        }
        list.set(i,root.val);
        levelOrder(root.left,2*i,list);
        levelOrder(root.right,2*i+1,list);
    }

前序、中序、后续、层序 递归遍历实验源码

package com.example.rabbitmq;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.LinkedList;
import java.util.Queue;

@SpringBootTest
/*
    二叉树遍历
 */
class SuanfaApplicationTests17 {

    //定义一个二叉树
    static class TreeNode{
        public int val;
        public TreeNode left;
        public TreeNode right;
        public int deep;//深度
        public TreeNode(){}
        public TreeNode(int val){this.val=val;}
        public TreeNode(int val,TreeNode left,TreeNode right){
            this.val=val;
            this.left=left;
            this.right=right;
        }
    }

    //1、前序-递归
    public static void preorder(TreeNode root){
        if(root==null){
            return;
        }
        System.out.println(root.val);//(第一次成为栈顶才打印)
        preorder(root.left);
        preorder(root.right);
    }

    //2、中序-递归
    public static void preorder1(TreeNode root){
        if(root==null){
            return;
        }
        preorder1(root.left);
        System.out.println(root.val);//(第二次成为栈顶时进行打印)
        preorder1(root.right);
    }

    //3、后序-递归
    public static void preorder2(TreeNode root){
        if(root==null){
            return;
        }
        preorder(root.left);
        preorder(root.right);
        System.out.println(root.val);//(第三次成为栈顶时进行打印)
    }

 //4、层序遍历
    public static void levelOrder(TreeNode root,int i, ArrayList list){
        if(root==null){
            return;
        }
        //为了防止数组越界，需要进行数组容量填充
        int lenght=list.size();
        if(lenght<=i){
            for (int j=0;j<=i-lenght;j++){
                list.add(lenght+j,null);
            }
        }
        list.set(i,root.val);
        levelOrder(root.left,2*i,list);
        levelOrder(root.right,2*i+1,list);
    }

    @Test
    public void sf0(){
        //构造一个二叉树
        TreeNode node7=new TreeNode(7,null,null);
        TreeNode node6=new TreeNode(6,null,null);
        TreeNode node5=new TreeNode(5,node6,node7);
        TreeNode node4=new TreeNode(4,null,null);
        TreeNode node3=new TreeNode(3,null,null);
        TreeNode node2=new TreeNode(2,node4,node5);
        TreeNode node1=new TreeNode(1,node2,node3);

        System.out.println("-------前序------");
        preorder(node1);
        System.out.println("-------中序------");
        preorder1(node1);
        System.out.println("-------后序------");
        preorder2(node1);
              System.out.println("-------层序遍历------");
        ArrayList list = new ArrayList();
        levelOrder(node1,1,list);
        Object collect = list.stream().filter(item -> item != null).collect(Collectors.toList());
        System.out.println(collect.toString());
    }

}

结果：

-------前序------
1
2
4
5
6
7
3
-------中序------
4
2
6
5
7
1
3
-------后序------
2
4
5
6
7
3
1
-------层序遍历------
[1, 2, 3, 4, 5, 6, 7]

5、前序遍历-迭代（模拟递归遍历）

   //1、前序-迭代：根   左  右
    public static void preorder(TreeNode root){
        if(root!=null){
            Stack<TreeNode> stack=new Stack<TreeNode>();
            stack.add(root);
            while (!stack.isEmpty()){
                root=stack.pop();
                if(root!=null){
                    System.out.println(root.val);
                    stack.push(root.right);
                    stack.push(root.left);
                }
            }
        }
    }

6、中序遍历-迭代（模拟递归遍历）

//2、中序-迭代：左  根  右
    public static void preorder1(TreeNode root){
        if(root!=null){
            Stack<TreeNode> stack=new Stack<TreeNode>();
            while (!stack.isEmpty()||root!=null){
                if(root!=null){
                    stack.push(root);
                    root=root.left;
                }else{
                    root=stack.pop();
                    System.out.println(root.val);
                    root=root.right;
                }
            }
        }
    }

7、后序遍历-迭代（模拟递归遍历）

//3、后序-迭代：左   右  根
    public static void preorder2(TreeNode root){
        if(root!=null){
            Stack<TreeNode> stack=new Stack<TreeNode>();
            TreeNode prev=null;//记录位置用
            while (!stack.isEmpty()||root!=null){
                if(root!=null){
                    stack.push(root);
                    root=root.left;
                }
                root=stack.pop();
                if(root.right==null||root.right==prev){
                    System.out.println(root.val);
                    prev=root;
                    root=null;
                }else {
                    stack.push(root);
                    root=root.right;
                }
            }
        }
    }

8、层序遍历-迭代（利用队列先进先出特点：从上到下、从左到右）

 //4、层序-迭代（利用队列先进先出特点）：从上到下、从左到右
    public static void preorder3(TreeNode root){
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);//入队
        while(!q.isEmpty()){
            TreeNode node = q.poll();//出队
            if(node!=null){
                System.out.println(node.val);
                q.add(node.left);
                q.add(node.right);
            }
        }
    }

前序、中序、后续、层序，遍历（迭代）实验源码：

package com.example.rabbitmq;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
import java.util.stream.Collectors;

@SpringBootTest
/*
    二叉树遍历-迭代
 */
class SuanfaApplicationTests18 {

    //定义一个二叉树
    static class TreeNode{
        public int val;
        public TreeNode left;
        public TreeNode right;
        public int deep;//深度
        public TreeNode(){}
        public TreeNode(int val){this.val=val;}
        public TreeNode(int val,TreeNode left,TreeNode right){
            this.val=val;
            this.left=left;
            this.right=right;
        }
    }

    //1、前序-迭代：根   左  右
    public static void preorder(TreeNode root){
        if(root!=null){
            Stack<TreeNode> stack=new Stack<TreeNode>();
            stack.add(root);
            while (!stack.isEmpty()){
                root=stack.pop();
                if(root!=null){
                    System.out.println(root.val);
                    stack.push(root.right);
                    stack.push(root.left);
                }
            }
        }
    }

    //2、中序-迭代：左  根  右
    public static void preorder1(TreeNode root){
        if(root!=null){
            Stack<TreeNode> stack=new Stack<TreeNode>();
            while (!stack.isEmpty()||root!=null){
                if(root!=null){
                    stack.push(root);
                    root=root.left;
                }else{
                    root=stack.pop();
                    System.out.println(root.val);
                    root=root.right;
                }
            }
        }
    }

    //3、后序-迭代：左   右  根
    public static void preorder2(TreeNode root){
        if(root!=null){
            Stack<TreeNode> stack=new Stack<TreeNode>();
            TreeNode prev=null;//记录位置用
            while (!stack.isEmpty()||root!=null){
                 while (root!=null){
                    stack.push(root);
                    root=root.left;
                }
                root=stack.pop();
                if(root.right==null||root.right==prev){
                    System.out.println(root.val);
                    prev=root;
                    root=null;
                }else {
                    stack.push(root);
                    root=root.right;
                }
            }
        }
    }

    //4、层序-迭代（利用队列先进先出特点）：从上到下、从左到右
    public static void preorder3(TreeNode root){
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);//入队
        while(!q.isEmpty()){
            TreeNode node = q.poll();//出队
            if(node!=null){
                System.out.println(node.val);
                q.add(node.left);
                q.add(node.right);
            }
        }
    }

    @Test
    public void sf0(){
        //构造一个二叉树
        TreeNode node7=new TreeNode(7,null,null);
        TreeNode node6=new TreeNode(6,null,null);
        TreeNode node5=new TreeNode(5,node6,node7);
        TreeNode node4=new TreeNode(4,null,null);
        TreeNode node3=new TreeNode(3,null,null);
        TreeNode node2=new TreeNode(2,node4,node5);
        TreeNode node1=new TreeNode(1,node2,node3);

        System.out.println("-------前序遍历-迭代（模拟递归）------");
        preorder(node1);

        System.out.println("-------中序遍历-迭代（模拟递归）------");
        preorder1(node1);

        System.out.println("-------后序遍历-迭代（模拟递归）------");
        preorder2(node1);

        System.out.println("-------层序遍历-迭代（模拟递归）------");
        preorder3(node1);
    }

}

结果：

-------前序遍历-迭代（模拟递归）------
1
2
4
5
6
7
3
-------中序遍历-迭代（模拟递归）------
4
2
6
5
7
1
3
-------后序遍历-迭代（模拟递归）------
4
6
7
5
2
3
1
-------层序遍历-迭代（模拟递归）------
1
2
3
4
5
6
7
会飞的小蜗
关注
专栏目录
C语言实现二叉树遍历的迭代算法
09-04
以上就是C语言实现二叉树遍历的迭代算法，通过这种方式，我们可以高效地遍历二叉树，而无需像递归那样增加调用栈的压力。这对于处理大规模数据或者深度很大的二叉树特别有用。在实际编程中，理解并掌握这些算法对...
【STL】常见遍历算法、查找算法、排序算法
qq_59702185的博客
09-12 1066
STL常用算法主要是由头文件《algorithm》、《functional》、《numeric》组成《algorithm》是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、遍历、赋值、修改等等《numeric》体积较小，只包括几个在序列上面进行简单数学运算的模板函数《functional》定义了一些模板类，用来声明函数对象（仿函数）
代码随想录 - 二叉树的各种遍历方法（Java）
weixin_45685902的博客
03-28 1184
那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了。分析一下为什么刚刚写的前序遍历的代码，不能和中序遍历通用呢，因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，所以刚刚才能写出相对简洁的代码，而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。我们以中序遍历为例，在。
二叉树遍历算法总结
KISS
06-20 975
文章目录前提要素深度优先搜索DFS经典遍历算法前序遍历递归版迭代版中序遍历递归版迭代版后序遍历递归版迭代版Morris遍历算法中序遍历前序遍历后序遍历广度优先搜索BFS按层遍历参考资料 前提要素 //二叉树节点结构 public static class TreeNode { public int val; public TreeNode left; public TreeNode right; public TreeNode(int x) { val = x; } public Tre
迭代法（迭代+栈）模拟递归实现深度优先搜索（DFS）：以力扣原题[112. 路径总和]及[113. 路径总和 II]为例
最新发布
bluecyan的博客
04-14 777
如果直接将 road 作为参数，因为是传引用，子递归对 road 的改变将直接影响上层递归中 road 的值（毕竟自始至终都是在对同一个对象做操作），如果要以用 road 做参数的方式实现回溯，需要在传递 road 时 new 一个新的对象，新对象即是子递归需要的新 road，将新对象作为参数传递给子递归函数，这样，每次递归调用时传入的 road 都不同，子递归对 road 的改变也就不会影响上层递归中 road 的值了。在状态转移中有一个深度优先搜索中重之又重的概念：回溯。
Java中的二叉树，前中后序遍历的递归和迭代写法。
回水的博客
06-15 1228
文章目录一、树是什么？树的特点二、二叉树1.概念及特点2.读入数据总结 一、树是什么？ 树是一种非线性的数据结构，它是由n(n >= 0)个有限结点组成的一个具有层次关系的集合。(线性数据结构就是：线性表，数组，栈，链表，队列，字符串…元素之间逻辑上一个挨着一个，呈值直线排列)把它叫做树是因为它看起来像一颗倒着的树，意思就是根朝上，叶子朝下。 树的特点 有一个特殊的结点，称为根节点，根节点没有前驱结点。 除根节点外，其余节点被分成M(M > 0) 个互不相交的集合T1、T2、…、Tm,其中
二叉树遍历问题，总结递归和迭代解法
11-29
} }总结二叉树的遍历是数据结构中的基础操作，理解递归和迭代解法对于解决更复杂的二叉树问题至关重要。递归方法简洁明了，易于理解，但可能会导致较大的函数调用开销。而迭代方法通常效率更高，但实现起来可能更...
LeetCode–144,94,145,102 二叉树的前序、中序、后序、层序遍历(递归，迭代，栈，队列)
12-21
二叉树遍历是计算机科学中处理二叉树数据结构的一种基本操作，它涉及到对树的所有节点按照特定的顺序...对于二叉树遍历，熟练掌握递归和迭代的实现方式是编程面试中常见的要求，也是理解和操作二叉树所必备的基础技能。
二叉树迭代遍历JAVA
qianhuan_的博客
07-14 409
二叉树迭代遍历
前中后序二叉树遍历迭代方法总结
fruit513的博客
12-27 595
//inorder public List&lt;Integer&gt; inorderTraversal(TreeNode root) { List&lt;Integer&gt; res=new ArrayList&lt;&gt;(); if (root==null) return res; Stack&lt;TreeNode&gt; s...
Java二叉树后序遍历：递归与迭代
进击的Coder*的博客
04-16 1247
二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 如下便是一棵二叉树： 二叉树的后序遍历方式为： 1. 如果根节点有左子树，遍历左子树 2. 如果根节点有右子树，遍历右子树 3. 遍历根节点 注意，上述步骤1、2同样以1、2、3的顺序进行遍历。 后序遍历方式1：迭代 public List<Integer> postorderTraversal(TreeNode root) {
java迭代实现二叉树先中后序遍历（非递归）
PacosonSWJTU的博客
11-21 951
本文复习了通过java迭代实现 二叉树先序，中序，后序遍历；本文引入了 栈，替换了递归，对二叉树进行遍历；缺点一旦二叉树节点个数过多，可能导致栈溢出的情况显式栈，可以用 数组来实现。
用Java实现二叉树的遍历
m0_61630116的博客
05-20 6829
树是一种非线性结构的数据结构，有一个点没有前驱，被称为根节点，它可以有多种变化，普通二叉树，N叉树，二叉搜索树（BST），红黑树（RBTree），B树等等，上述所说的树中，普通二叉树就算是比较简单的数据结构。 二叉树的存储： 二叉树的存储方式分为：顺序存储和类似于链表的链式存储。 二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式。 我们使用孩子表示法来给大家解释一下 class TreeNode { public char val;//数据 pu
java递归函数返回值_Java基础——方法返回值&递归
weixin_29735807的博客
02-13 1196
声明：本栏目所使用的素材都是凯哥学堂VIP学员所写，学员有权匿名，对文章有最终解释权；凯哥学堂旨在促进VIP学员互相学习的基础上公开笔记。例题：写一个方法，功能是排序，然后颠倒我给你的方法传递一个数组，你就能把这个数组进行排序后倒序，然后在main方法输出的时候就能看到你运行后结果方法返回值：方法结束后反馈了个结果。过程和方法类似，但是过程没有返回值。返回值只能是一个类型，只能是一个值，不能多值返...
Java实现二叉树的递归遍历(前序遍历、中序遍历、后序遍历)
qq_43751200的博客
07-19 1562
实现二叉树的递归遍历
java 快速从树节点找到数据_Java中用递归和迭代实现二叉树的中序（ InOrder )遍历...
weixin_39815410的博客
11-22 259
与数组和链表不同，二叉树有几种遍历方式。遍历算法大致分为深度优先和广度优先遍历算法，这取决于算法实际如何工作。顾名思义，深度优先在访问同级别兄弟之前先向二叉树纵深访问，而广度优先是先访问同一级别中的所有节点然后再进入下一级别，因此它也被称为级别顺序遍历。 PreOrder和InOrder树遍历算法都是深度优先的，预序和中序算法之间的唯一区别是访问二叉树的根，左节点和右节点的顺序。InOrder遍历...
java使用递归，非递归方式实现二叉树的三种常见遍历方式
热门推荐
奔跑的蜗牛的博客
03-07 1万+
二叉树的定义： 二叉树(binary tree)是结点的有限集合，这个集合或者空，或者由一个根及两个互不相交的称为这个根的左子树或右子树构成. 从定义可以看出，二叉树包括：1.空树 2.只有一个根节点 3.只有左子树 4.只有右子树 5.左右子树都存在 有且仅有这5中表现形式  二叉树的特点： 性质1：在二叉树的第i层上至多有2^(i-1
java 递归二叉树遍历二叉树_Java通过递归进行二叉树遍历
weixin_42549723的博客
03-05 258
搜索热词下面是编程之家 jb51.cc 通过网络收集整理的代码片段。编程之家小编现在分享给大家，也给大家做个参考。// 测试二叉树遍历,递归算法public class TestBinaryTree {public static void main(String[] args) {Node g = new Node("G",null,null);Node e = new Node("E",null...
二叉树遍历：递归与迭代方法详解及代码实例
本文档深入探讨了二叉树遍历问题，重点介绍了前序遍历、中序遍历、后序遍历和层序遍历这四种常见的二叉树遍历方式。首先，我们回顾了二叉树的基本概念，它是一种特殊的树形数据结构，每个节点最多有两个子节点，通常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

会飞的小蜗

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

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

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

打赏作者

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

抵扣说明：

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

余额充值