二叉树的前、中、后序遍历（递归方法 + 非递归方法）

最新推荐文章于 2024-07-06 14:24:03 发布
最新推荐文章于 2024-07-06 14:24:03 发布
阅读量440 收藏
点赞数
分类专栏： 数据结构与算法 Java 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45478540/article/details/124302867
版权

树结构

二叉树

为什么需要树这种数据结构

数组存储方式的分析

在这里插入图片描述
优点： 通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度！

缺点： 如果检索某个具体值时，或者插入值（按一定顺序）会整体移动，效率较低

链式存储方式的分析

在这里插入图片描述
优点： 在一定程度上对数组存储方式有优化（比如：插入一个数值节点，只需要将插入的节点链接到链表中即可，删除节点效率也很好）!

缺点： 在进行检索时，效率较低，比如（检索某个值时，需要从头节点开始遍历）！

树存储方式的分析

在这里插入图片描述

能提高数据存储，读取的效率，比如利用 二叉排序树（Binary Sort Tree），既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度！

前序、中序、后序遍历

例图

在这里插入图片描述
在这里插入图片描述

代码

package com.xoste.datastructure.binarytree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

/**
 * @author xoste
 * @date 2022/4/19 14:32
 */
public class BinaryTree {

    private HeroNode root;

    public HeroNode getRoot() {
        return root;
    }

    public void setRoot(HeroNode root) {
        this.root = root;
    }

    /**
     * 递归方法
     * 前序遍历
     */
    public void preorder() {
        if (this.root != null) {
            this.root.preorder();
        } else {
            System.out.println("二叉树为空...");
        }
    }

    /**
     * 非递归方法
     * 前序遍历
     */
    public void preOrder() {
        if (this.root != null) {
            this.root.preOrderTraverse();
        } else {
            System.out.println("二叉树为空");
        }
    }

    /**
     * 递归方法
     * 中序遍历
     */
    public void inorder() {
        if (this.root != null) {
            this.root.inorder();
        } else {
            System.out.println("二叉树为空...");
        }
    }

    /**
     * 非递归方法
     * 中序遍历
     */
    public void inOrder() {
        if (this.root != null) {
            this.root.inOrderTraverse();
        } else {
            System.out.println("二叉树为空");
        }
    }

    /**
     * 递归方法
     * 后序遍历
     */
    public void postorder() {
        if (this.root != null) {
            this.root.postorder();
        } else {
            System.out.println("二叉树为空...");
        }
    }

    /**
     * 非递归方法
     * 后序遍历
     */
    public void postOrder() {
        if (this.root != null) {
            this.root.postOrderTraverse();
        } else {
            System.out.println("二叉树为空");
        }
    }

    public static void main(String[] args) {
        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");
        HeroNode node5 = new HeroNode(5, "关胜");
//        HeroNode node6 = new HeroNode(6, "鲁智深");

        root.setLeftNode(node2);
        root.setRightNode(node3);
//        node2.setRightNode(node6);
        node3.setRightNode(node4);
        node3.setLeftNode(node5);
        BinaryTree binaryTree = new BinaryTree();
        binaryTree.setRoot(root);

        // 递归方法
//        System.out.println("前序遍历");
//        binaryTree.preorder();
//        System.out.println("中序遍历");
//        binaryTree.inorder();
//        System.out.println("后序遍历");
//        binaryTree.postorder();

        // 非递归方法
        System.out.println("前序遍历");
        binaryTree.preOrder();
        System.out.println("中序遍历");
        binaryTree.inOrder();
        System.out.println("中序遍历");
        binaryTree.postOrder();
    }
}

class HeroNode {
    private int id;
    private String name;
    private HeroNode leftNode;
    private HeroNode rightNode;

    public HeroNode(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(HeroNode leftNode) {
        this.leftNode = leftNode;
    }

    public HeroNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(HeroNode rightNode) {
        this.rightNode = rightNode;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", leftNode=" + leftNode +
                ", rightNode=" + rightNode +
                '}';
    }

    /**
     * 递归方法
     * 前序遍历
     */
    public void preorder() {
        // 输出根节点，这里的 this 就是 BinaryTree类 中的成员变量 root，因为 this.root.preorder()
        // this 调用谁，谁就是 this
        System.out.println(this);
        // 向左遍历
        if (this.leftNode != null) {
            this.leftNode.preorder();
        }
        // 向右遍历
        if (this.rightNode != null) {
            this.rightNode.preorder();
        }
    }

    /**
     * 非递归方法
     * 前序遍历
     */
    public void preOrderTraverse() {
        // 定义一个辅助指针指向根节点
        HeroNode temp = this;
        Stack<HeroNode> stack = new Stack<>();
        List<HeroNode> list = new LinkedList<>();
        while (temp != null) {
            // 向左遍历
            while (temp != null) {
                // 将当前节点添加到 list 集合中
                list.add(temp);
                if (temp.getRightNode() != null) {
                    // 如果当前节点的右节点不为空，就先把右节点入栈，存起来，等所有的左节点数据遍历完后，
                    // 再将右节点从栈中取出，继续向左遍历，存储右节点...直到右节点为空
                    stack.push(temp.getRightNode());
                }
                // 将当前节点的指针指向当前节点的左节点
                temp = temp.getLeftNode();
            }

            if (stack.size() > 0) {
                // 将存到栈中右节点取出，即当前节点指针指向右节点，继续上面操作
                temp = stack.pop();
            }
        }
        list.forEach(System.out::println);
    }

    /**
     * 递归方法
     * 中序遍历
     */
    public void inorder() {
        // 向左遍历
        if (this.leftNode != null) {
            this.leftNode.inorder();
        }
        // 输出根节点
        System.out.println(this);
        // 向右遍历
        if (this.rightNode != null) {
            this.rightNode.inorder();
        }
    }

    /**
     * 非递归方法
     * 中序遍历
     */
    public void inOrderTraverse() {
        // 定义一个辅助指针 temp 指向根节点
        HeroNode temp = this;
        List<HeroNode> list = new ArrayList<>();
        Stack<HeroNode> stack = new Stack<>();
        while (temp != null || !stack.isEmpty()) {
            // 一直向左遍历
            while (temp != null) {
                // 将 根节点 入栈
                stack.push(temp);
                temp = temp.getLeftNode();
            }

            if (stack.size() > 0) {
                // 从栈中取出栈顶的 根节点
                temp = stack.pop();
                // 将当前节点添加到 list 集合中
                list.add(temp);
                // 向右遍历
                temp = temp.getRightNode();
            }
        }
        list.forEach(System.out::println);
    }

    /**
     * 递归方法
     * 后序遍历
     */
    public void postorder() {
        // 向左遍历
        if (this.leftNode != null) {
            this.leftNode.postorder();
        }
        // 向右遍历
        if (this.rightNode != null) {
            this.rightNode.postorder();
        }
        // 输出根节点
        System.out.println(this);
    }

    /**
     * 非递归方法
     * 后序遍历
     */
    public void postOrderTraverse() {
        // 定义辅助指针 temp 指向根节点
        HeroNode temp = this;
        List<HeroNode> list = new ArrayList<>();
        Stack<HeroNode> stack = new Stack<>();
        while (temp != null || !stack.isEmpty()) {
            // 一直向左遍历
            while (temp != null) {
                // 将根节点入栈
                stack.push(temp);
                if (temp.getLeftNode() != null) {
                    temp = temp.getLeftNode();
                } else {
                    temp = temp.getRightNode();
                }
            }
            if (stack.size() > 0) {
                // 从栈中取出栈顶元素
                temp = stack.pop();
                // 将当前元素添加到 list 集合中
                list.add(temp);
            }
            // 当栈不为空，且栈顶元素的右节点 = 当前节点，取栈顶元素
            while (stack.size() > 0 && stack.peek().getRightNode() == temp) {
                // 取栈顶元素
                temp = stack.pop();
                // 将当前节点添加到 list 集合中
                list.add(temp);
            }

            // 当栈不为空时，temp 就只指向栈顶元素的右节点
            if (stack.size() > 0) {
                temp = stack.peek().getRightNode();
            } else {
                temp = null;
            }
        }
        list.forEach(System.out::println);
    }
}

运行结果截图
在这里插入图片描述

该文章来源于 B站，韩顺平老师的数据结构与算法教程！

xoste
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 — 实现二叉树的前序，中序，后序遍历(非递归)
阿亮的博客
07-26 1685
实现二叉树的前序，中序，后序遍历 ————————————————————————————— 相信大家对二叉树已经很了解了，我以前写过一个二叉树的基本操作的博客，里面有很多二叉树的很多功能，比如高度，叶子结点 个数什么的都很简单，但是大多数都是递归实现的，可能思考过程会相比较简单一点，我当时没有写到二叉树的前序，中序，后序 的非递归遍历，这里
二叉树遍历(递归实现前序/中序/后序遍历)
不见其长，日有所长
06-17 1259
1. 准备工作 我们先定义一棵普通的二叉树，如下图 2. 前序遍历 通过递归进行遍历： 如果二叉树为空，则操作返回； 如果非空，否则从根结点开始，然后遍历左子树，再遍历右子树。 前序遍历的结果是：ABDGHEICFJK 为什么会遍历出这种结果，请看上面对前序遍历的描述：先遍历左边，然后在遍历右边。 JAVA代码如下： //前序遍历 public static void preTraversal(Node node){ if(null!=node){ System.out.println(nod
二叉树的前序、中序、后序遍历（递归、非递归写法）
m0_62021646的博客
05-13 1870
文章目录一、什么是二叉树？二、二叉树的基本概念三、二叉树的三种遍历方式1.前序遍历（preordertraversal）1.中序遍历（inordertraversal）1.后序遍历（postordertraversal）四、代码实现1.建树过程2.递归写法3.非递归写法4.完整代码 一、什么是二叉树？ 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。
二叉树遍历(先序，中序，后序，层序)递归和非递归形式
weixin_57023347的博客
06-13 2725
文章目录1.先序遍历定义递归非递归2.中序遍历定义递归非递归3.后序遍历定义递归非递归4.层序遍历定义：代码实现(队列) 二叉树的遍历是通过一定顺序来访问二叉树的所有结点。遍历的方法有四种：先序遍历，中序遍历，后序遍历和层序遍历。 其中前三种一般使用深度优先搜索(DBS)实现,而层次遍历一般用广度优先搜索(BFS)实现。 二叉树表示： struct TreeNone{ int data; struct TreeNone *lchild; struct TreeNone *rchild; }; 注
二叉树三种（前序中序后序）遍历方式（递归版和非递归版）
AC__dream的博客
05-10 2520
递归遍历二叉树比较容易理解，就直接按照遍历方式的定义来做就行了。关键是非递归遍历二叉树。 先说一下递归遍历二叉树，三种序列遍历方式的大致结构是一样的，都是先递归遍历左子树，再递归遍历右子树，区别就在于访问节点的顺序不同，先序遍历是先访问根节点再访问左子树和右子树，所以是在一开始就输出节点值，而中序遍历是先访问左子树再访问根节点最后访问右子树，也就是说在递归遍历完当前节点左子树后进行当前节点值输出，而后序遍历是访问完当前节点左子树和右子树后再进行当前节点值的输出。 而非递归遍历二叉树的实现过程的大体框架也
二叉树的非递归后序遍历算法实例详解
09-04
主要介绍了二叉树的非递归后序遍历算法实例,需要的朋友可以参考下
表达式求值（二叉树非递归后序遍历）.zip
09-15
用非递归后序遍历二叉树的方式实现的表达式计算，进行了精细的表达式逻辑判断和处理，可进行加减乘除、括号、小数的计算。项目结构清晰，基本都有代码注释，可用于数据结构实验。同为学习人，能力有限，不足之处还请...
链式二叉树的后序创建、递归后序遍历、非递归堆栈后序遍历、后序销毁
06-13
在二叉树中，遍历是访问每个节点的过程，有三种主要的遍历方式：前序遍历、中序遍历和后序遍历。本主题聚焦于后序遍历，它对于理解和操作二叉树至关重要。 后序遍历（Postorder Traversal）的顺序是：先访问左子树...
C语言非递归后序遍历二叉树
08-29
"C语言非递归后序遍历二叉树" ...非递归后序遍历二叉树可以使用栈或标记来实现，这两种方法都可以实现非递归后序遍历二叉树，但它们之间有一些差异。在实际应用中，我们可以根据具体情况选择合适的方法。
二叉树的前序、中序和后序遍历（递归和非递归的方法）
EngineerHe的博客
02-06 1万+
二叉树的前序、中序和后序遍历（递归和非递归的方法） 二叉树的基础概念 二叉树： 是每个节点最多只有两个分支的树结构。通常分支被称为”左子树“和”右子树“。二叉树的分支具有左右次序，不能随意颠倒。 下图是一棵二叉树 二叉树还有如下的性质： 二叉树的第 iii 层至多有 2i−12^{i-1}2i−1 个节点 深度为 kkk 的二叉树至多有 2k−12^k-12k−1 个节点 一颗含有 nnn 个...
一文彻底搞定二叉树的前序、中序、后序遍历(图解递归非递归)
热门推荐
bigsai
09-22 1万+
前言 大家好，我是bigsai，在数据结构与算法中，二叉树无论是考研、笔试都是非常高频的考点内容，在二叉树中，二叉树的遍历又是非常重要的知识点，今天给大家讲讲二叉树的层序遍历。 这部分很多人可能会但是需要注重一下细节。 前面介绍了二叉排序树的构造和基本方法的实现，遍历也是比较重要的一环，并且二叉树的层序遍历也是bfs的最简单情况，这里我就将二叉树的层序遍历以及常考问题给大家分享一下。 在了解二叉树的遍历之前，需要具备数据结构与算法有队列、递归、栈、二叉树，这些内容咱们前面都有讲过，有这方面知识欠缺的同学可以
数据结构与算法—二叉树的层序、前序中序后序(递归、非递归)遍历
bigsai
08-21 8689
目录前言 层序遍历 前中后序遍历(递归) 前言 前面介绍了二叉排序树的构造和基本方法的实现。但是排序遍历也是比较重要的一环。所以笔者将前中后序.和层序遍历梳理一遍。 了解树的遍历，需要具有的只是储备有队列，递归，和栈。这里笔者都有进行过详细介绍，可以关注笔者数据结构与算法专栏。持续分享，共同学习。 层序遍历 层序遍历。听名字也知道是按层遍历。我们知道一个节点有左右节点。而每一层一层的遍...
非递归实现二叉树先序、中序和后序遍历
沐雨金鳞
09-25 556
平时都写递归的，非递归的都忘光光了，学习一下???? 非递归实现二叉树先序、中序和后序遍历 用递归方式实现二叉树先序、中序和后序遍历很简单。 用递归方法解决的问题都能用非递归的方法实现。递归就是利用函数栈来保存信息，如果用自己申请的数据结构来代替函数栈，也可以实现相同的功能。 用非递归的方式实现二叉树的先序遍历（LeetCode144）： 1、申请一个栈stack，然后将头节点压入stack中。 2、从stack中弹出栈顶节点，打印，再将其右孩子节点（不为空的话）先压入stack中，最后将其左孩
数据结构：二叉树的构建、前中后序遍历（递归vs非递归）思路及代码
sunny_yeah_的博客
07-03 932
二叉树的基本操作二叉树的创建构建二叉树的类对象先序遍历递归非递归中序遍历递归非递归后序遍历递归非递归层序遍历求解二叉树的高度最大高度最小高度 二叉树的创建 构建二叉树的类对象 在创建一棵二叉树之前，我们先创建一个二叉树的类对象Tree。类中包含的成员变量有：val、left、right，函数接口包括：先序遍历、中序遍历、后序遍历、层序遍历、二叉树高度 typedef int TreeElemt; class Tree{ public: enum Mode{NUM, CHAR}; private:
使用递归方式进行二叉树的前中后序遍历
ziupan的博客
03-14 2014
function.h #pragma once #include <stdio.h> #include <stdlib.h> typedef char ElemType; //树的链式存储结构--创建一个完全二叉树 //层次建树必须要用队列 typedef struct BiTiNode { ElemType data;//数据域 struct BiTiNode* lchild, * rchild;//左右孩子指针 }BiTiNode, *BiTree; //队列（用于辅助层
二叉树的前序、中序、后序遍历（递归）
weixin_42237761的博客
02-08 1984
二叉树的前序中序后序遍历（递归）
(5) 深入探索Python-Pandas库的核心数据结构：Series详解
最新发布
架构筑梦的Cherry Yang的博客
07-06 894
# 1. Series 简介 pandas数据结构中的Series是一个一维数组对象，能够保存任何数据类型（整数、字符串、浮点数、Python对象等），并有一个与之关联的标签序列，这些标签被称为“索引”（index）。索引与数据是一一对应的，通过索引可以快速获取、更新或删除数据。Series在pandas数据处理中起着至关重要的作用，是构建更复杂数据结构（如DataFrame）的基础。 以下是关于pandas Series的详细解释： * **定义**：Series类似于一维数组或列表，但它有一个显式的
数据结构第07节：队列
hummhumm的专栏
07-04 492
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
数据结构——带环链表、循环队列问题
2402_83657626的博客
07-02 532
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。以上便是本期讨论的两个数据结构问题，欢迎大家评论讨论交流。快指针一次走两步慢指针一次走一步。代码实现：（链表的实现请跳转☞。
c语言实现二叉树的前中后序遍历非递归完整代码
11-04
以下是C语言实现二叉树的前中后序遍历非递归完整代码： ```c #include #include #define MAXSIZE 100 typedef struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; } TreeNode; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值