二叉树操作-树的前序中序后续遍历的递归和非递归实现

最新推荐文章于 2023-02-16 12:01:31 发布
最新推荐文章于 2023-02-16 12:01:31 发布
阅读量420 收藏 3
点赞数 1
分类专栏： 算法与数据结构 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26356861/article/details/117637368
版权

二叉树操作

一、实验内容

二叉树的建立，二叉树的遍历。

二、实验目的

1． 进一步掌握指针变量的使用。

2． 掌握二叉树的结构特征，以及各种存储结构的特点及使用范围。

3． 掌握用指针类型描述、访问和处理二叉树的运算；

4． 掌握栈或队列的使用。

三、实验题目

本实验要求实现以下功能：

1．按前序次序建立一颗二叉树，以‘＃’表示空。

2．中序、后序遍历该二叉树，输出遍历序列。

3．求出该二叉树的深度并输出，或求出该二叉树的叶子数目并输出。

4．试以栈为辅助存储结构实现二叉树的前序非递归算法或以队列为辅助存储结构实现二叉树的层次遍历算法。（选做）

[测试数据]：

输入以下字符串，建立二叉树：ABC##DE#G##F###

输出中序遍历序列应为：CBEGDFA

输出后序遍历序列应为：CGEFDBA

输出二叉树的深度应为：5

输出二叉树的叶子数目应为：3

四、程序代码

package com.xrw.tree;

import java.util.Stack;

/**
 * @program: DataStructures
 * @description: 二叉树的建立与遍历
 * @author: 谢荣旺 1429382875@qq.com
 * @create: 2021-04-26 19:51
 **/
public class BinaryTreeTest {
    public static void main(String[] args) {
        String pre = "ABC##DE#G##F###";
        System.out.printf("创建二叉树的前序字符串为：%s\n",pre);
        Stack<String> stack = new Stack<>();
        int i = pre.length()-1;
        System.out.print("将字符串存放到栈中：");
        for (;i>=0;i--){
            stack.push(pre.substring(i,i+1));
        }
        String[] objects = new String[stack.size()];
        objects = stack.toArray(objects);
        for (String s: objects){
            System.out.print(s);
        }
        System.out.println();
        BinaryTree binaryTree = new BinaryTree();
        binaryTree.binaryTreeByPre(stack);

        System.out.println("二叉树的前序遍历为：");
        binaryTree.listByPre();
        System.out.println();

        System.out.println("二叉树的中序遍历为：");
        binaryTree.listByInfix();
        System.out.println();

        System.out.println("二叉树的后序遍历为：");
        binaryTree.listByPost();
        System.out.println();

        System.out.printf("二叉树的深度为：%d\n",binaryTree.deep());

        System.out.println("二叉树叶子节点为：");
        System.out.printf("二叉树叶子节点个数为：%d\n",binaryTree.leafNode());

        System.out.println("前序非递归遍历二叉树：");
        binaryTree.listByPreWithNonRecursive();
        System.out.println();

        System.out.println("中序非递归遍历二叉树：");
        binaryTree.listByInfixWithNonRecursive();
        System.out.println();

        System.out.println("后序非递归遍历二叉树：");
        binaryTree.listByPostWithNonRecursive();
        System.out.println();

    }
}

/**
 * @Description: 二叉树
 * @Author: 谢荣旺
 * @Date: 2021/4/27
 */
class BinaryTree{
    /**
     * 二叉树的根节点
     */
    TreeNode rootNode;

    /**
     * @Description: 构造方法，创建一个默认根节点的二叉树
     * @Author: 谢荣旺
     * @Date: 2021/4/27
     */
    public BinaryTree(){
        this.rootNode = new TreeNode("root");
    }

    /**
     * @Description: 通过前序的字符串序列构造出来的栈创建一个二叉树，字符串中空子树用#代替
     * @param stack: 字符串序列构造的栈
     * @return: com.xrw.tree.BinaryTree
     * @Author: 谢荣旺
     * @Date: 2021/4/27
     */
    public BinaryTree binaryTreeByPre(Stack<String> stack){
        if (stack.isEmpty() || "#".equals(stack.peek())){
            return this;
        }else {
            rootNode = new TreeNode(stack.pop());
            rootNode.createByPre(stack);
            return this;
        }
    }

    /**
     * 递归先序遍历
     */
    public void listByPre(){
        rootNode.listByPre();
    }

    /**
     * 递归中序遍历
     */
    public void listByInfix(){
        rootNode.listByInfix();
    }

    /**
     * 递归后续遍历
     */
    public void listByPost(){
        rootNode.listByPost();
    }

    /**
     * 求树的深度
     * @return
     */
    public int deep(){
        return rootNode.deep();
    }

    /**
     * 求树的叶子节点个数，并打印出叶子节点
     * @return
     */
    public int leafNode(){
        return rootNode.leftNode();
    }

    /**
     * @Description: 树的非递归先序遍历
     * @Author: 谢荣旺
     * @Date: 2021/4/27
     */
    public void listByPreWithNonRecursive(){
        rootNode.listByPreWithNonRecursive();
    }

    /**
     * @Description: 树的非递归中序遍历
     * @Author: 谢荣旺
     * @Date: 2021/4/27
     */
    public void listByInfixWithNonRecursive(){
        rootNode.listByInfixWithNonRecursive();
    }

    /**
     * @Description: 树的非递归后序遍历
     * @Author: 谢荣旺
     * @Date: 2021/4/27
     */
    public void listByPostWithNonRecursive(){
        rootNode.listByPostWithNonRecursive();
    }
}

/**
 * @Description: 二叉树结点类
 * @Author: 谢荣旺
 * @Date: 2021/4/27
 */
class TreeNode{
    /**
     * 结点数据
     */
    String data;
    /**
     * 左子树
     */
    TreeNode left;
    /**
     * 右子树
     */
    TreeNode right;

    /**
     * @Description: 构造函数，构造一个无子树的结点
     * @param data: 结点的数据
     * @Author: 谢荣旺
     * @Date: 2021/4/27
     */
    public TreeNode(String data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }

    @Override
    public String toString() {
        return data;
    }

    /**
     * @Description: 通过前序的字符串序列构造出来的栈创建一个二叉树，字符串中空子树用#代替
     * @param stack: 字符串序列构造的栈
     * @return: com.xrw.tree.BinaryTree
     * @Author: 谢荣旺
     * @Date: 2021/4/27
     */
    public void createByPre(Stack<String> stack){
        if (stack.empty()){
            return;
        }

        if (!"#".equals(stack.peek())){
            this.left = new TreeNode(stack.pop());
            this.left.createByPre(stack);
        }else {
            stack.pop();
        }

        if (stack.empty()){
            return;
        }

        if (!"#".equals(stack.peek())){
            this.right = new TreeNode(stack.pop());
            this.right.createByPre(stack);
        }else {
            stack.pop();
        }
    }

    /**
     * 递归先序遍历
     */
    public void listByPre(){
        System.out.print(this);
        if (left != null){
            left.listByPre();
        }
        if (right != null){
            right.listByPre();
        }
    }

    /**
     * 递归中序遍历
     */
    public void listByInfix(){
        if (left != null){
            left.listByInfix();
        }
        System.out.print(this);
        if (right != null){
            right.listByInfix();
        }
    }

    /**
     * 递归后续遍历
     */
    public void listByPost(){
        if (left != null){
            left.listByPost();
        }
        if (right != null){
            right.listByPost();
        }
        System.out.print(this);
    }

    /**
     * 求树的深度
     * @return
     */
    public int deep(){
        int deep = 1;
        if (left == null && right == null){
        }else if (left == null){
            deep += right.deep();
        }else if (right == null){
            deep += left.deep();
        }else {
            int sonDeep = Math.max(left.deep(), right.deep());
            deep += sonDeep;
        }
        return deep;
    }

    /**
     * 求树的叶子节点个数，并打印出叶子节点
     * @return
     */
    public int leftNode(){
        int num = 0;
        if (left == null && right == null){
            System.out.println(this);
            num = 1;
        }else if (left == null){
            num += right.leftNode();
        }else if (right == null){
            num += left.leftNode();
        }else {
            num += left.leftNode();
            num += right.leftNode();
        }
        return num;
    }

    /**
     * @Description: 树的非递归先序遍历
     * @Author: 谢荣旺
     * @Date: 2021/4/27
     */
    public void listByPreWithNonRecursive(){
        Stack<TreeNode> stack = new Stack<>();
        stack.push(this);
        TreeNode temp;

        while (!stack.isEmpty()){
            temp = stack.pop();
            System.out.print(temp.data);
            if (temp.right != null){
                stack.push(temp.right);
            }
            if (temp.left != null){
                stack.push(temp.left);
            }
        }
    }

    /**
     * @Description: 树的非递归中序遍历
     * @Author: 谢荣旺
     * @Date: 2021/4/27
     */
    public void listByInfixWithNonRecursive(){
        Stack<TreeNode> stack = new Stack<>();
        stack.push(this);
        TreeNode temp;

        while (!stack.isEmpty()){
            temp = stack.peek();
            while (temp.left != null){
                stack.push(temp.left);
                temp = temp.left;
            }
            temp = stack.pop();
            System.out.print(temp.data);
            while (temp.right == null && !stack.empty()){
                temp = stack.pop();
                System.out.print(temp.data);
            }
            if (temp.right != null){
                stack.push(temp.right);
            }
        }
    }

    /**
     * @Description: 树的非递归后序遍历
     * @Author: 谢荣旺
     * @Date: 2021/4/27
     */
    public void listByPostWithNonRecursive(){
        Stack<TreeNode> stack = new Stack<>();
        Stack<TreeNode> stack2 = new Stack<>();
        stack.push(this);
        TreeNode temp;

        while (!stack.isEmpty()){
            temp = stack.pop();
            stack2.push(temp);
            if (temp.left != null){
                stack.push(temp.left);
            }
            if (temp.right != null){
                stack.push(temp.right);
            }
        }

        while (!stack2.isEmpty()){
            System.out.print(stack2.pop());
        }
    }
}

五、实验结果

创建二叉树的前序字符串为：ABC##DE#G##F###
将字符串存放到栈中：###F##G#ED##CBA
二叉树的前序遍历为：
ABCDEGF
二叉树的中序遍历为：
CBEGDFA
二叉树的后序遍历为：
CGEFDBA
二叉树的深度为：5
二叉树叶子节点为：
C
G
F
二叉树叶子节点个数为：3
前序非递归遍历二叉树：
ABCDEGF
中序非递归遍历二叉树：
CBEGDFA
后序非递归遍历二叉树：
CGEFDBA

Process finished with exit code 0

六、实验小结

通过这次实验，掌握了二叉树的结构，理解了二叉树的实现原理，实现了常规的递归前序、中序、后序遍历二叉树和用非递归的方法前序、中序、后序遍历二叉树，极大的强化了我的思维逻辑能力。

谢小鱼
关注
专栏目录
一文彻底搞定二叉树的前序、中序、后序遍历(图解递归非递归)
bigsai
09-22 1万+
前言 大家好，我是bigsai，在数据结构与算法中，二叉树无论是考研、笔试都是非常高频的考点内容，在二叉树中，二叉树的遍历又是非常重要的知识点，今天给大家讲讲二叉树的层序遍历。 这部分很多人可能会但是需要注重一下细节。 前面介绍了二叉排序树的构造和基本方法的实现，遍历也是比较重要的一环，并且二叉树的层序遍历也是bfs的最简单情况，这里我就将二叉树的层序遍历以及常考问题给大家分享一下。 在了解二叉树的遍历之前，需要具备数据结构与算法有队列、递归、栈、二叉树，这些内容咱们前面都有讲过，有这方面知识欠缺的同学可以
二叉树的中序、前序和后序遍历(C++)
weixin_44810568的博客
01-25 764
二叉树的中序、前序和后序遍历(C++)
c语言实现二叉树的先序，中序，后续遍历（非递归）
blast_dragon的博客
05-16 1722
二叉树的递归遍历很简单，就不详述了。而非递归遍历有一定的难度，所以专门写一篇文章来总结这三种非递归遍历。废话不多说，直接进入正题 在讲非递归遍历之前，先讲一下栈，这是非递归算法的核心思想。 如图： 栈是后进先出，先进后出，我想既然大家都学到二叉树了，那么栈肯定也不陌生，我主要想加深大家对栈的理解。 试想，你在浏览网页的时候，突然发现了一个有趣的链接，你点击进去，发现原来是广告，于是你想退回到上一个网页，那么点击浏览器上方的后退图标就很轻松地退回去了。 那么，你点击一个网页，再点击一个网页，就是个进栈的过程
非递归实现二叉树先序、中序和后序遍历
沐雨金鳞
09-25 565
平时都写递归的，非递归的都忘光光了，学习一下???? 非递归实现二叉树先序、中序和后序遍历 用递归方式实现二叉树先序、中序和后序遍历很简单。 用递归方法解决的问题都能用非递归的方法实现。递归就是利用函数栈来保存信息，如果用自己申请的数据结构来代替函数栈，也可以实现相同的功能。 用非递归的方式实现二叉树的先序遍历（LeetCode144）： 1、申请一个栈stack，然后将头节点压入stack中。 2、从stack中弹出栈顶节点，打印，再将其右孩子节点（不为空的话）先压入stack中，最后将其左孩
C语言实现树与二叉树的转换，树的前序、后序的递归算法和非递归算法
weixin_45645828的博客
02-16 1181
C语言实现树与二叉树的转换,树的前序、后序的递归算法和非递归算法的实现，层次序的非递归算法实现
二叉树先序、中序、后序、层序遍历非递归实现
curelmn的博客
03-21 247
一、先序遍历非递归实现 1.先创建一个栈 2.把根节点放入栈中 3.循环取栈顶元素 4.访问这个元素，并出栈 5.把当前元素的右子树入栈 6.把当前元素的左子树入栈 7.循环该过程 public static void preOrderNoR(TreeNode root){ if(root==null){ return; } //1.创建一个栈 Stack<TreeNode> sta
二叉树先序、中序、后序遍历的递归和非递归实现
dao_lian的博客
05-06 430
二叉树的六种遍历方式（其中控制台输出代表访问） 1.递归先序 public void recursion_pre(TreeNode root) { if (root==null) return; System.out.print(root.val); recursion_pre(root.left); ...
二叉树的前序、中序、后序遍历（递归、非递归写法）
m0_62021646的博客
05-13 1915
文章目录一、什么是二叉树？二、二叉树的基本概念三、二叉树的三种遍历方式1.前序遍历（preordertraversal）1.中序遍历（inordertraversal）1.后序遍历（postordertraversal）四、代码实现1.建树过程2.递归写法3.非递归写法4.完整代码 一、什么是二叉树？ 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。
C语言实现二叉树的前序、中序、后续遍历非递归法.doc
07-02
C语言实现二叉树的前序、中序、后续遍历非递归法
实现二叉树的先序、中序、后序遍历，包括递归方式和非递归方式
BUPT-WT的博客
07-02 306
class TreeNode: def __init__(self,x): self.value = x self.right = None self.left = None def createTree(root): data = input("input data") if data...
快速排序算法设计与分析总结 二叉树与树的转换前序、后序的递归、非递归算法，层次序的非递归算法的实现
06-23
快速排序算法设计与分析总结 二叉树与树的转换前序、后序的递归、非递归算法，层次序的非递归算法的实现 二叉树与树的转换前序、后序的递归、非递归算法，层次序的非递归算法的实现，应包含建树的实现 实现树与二叉树的转换的实现。以及树的前序、后序的递归、非递归算法，层次序的非递归算法的实现，应包含建树的实现。
二叉树的非递归建立，前序、中序、后序遍历
07-17
关于数据结构实验的二叉树问题
数据结构（二叉树篇）------实现递归与非递归方法的二叉树先序、中序、后序遍历
weixin_44689331的博客
04-19 829
数据结构（二叉树篇）------实现递归与非递归方法的二叉树先序、中序、后序遍历，链栈的简单实现
数据结构实验之——二叉树前中后递归和非递归遍历的实现
Xmumu_的博客
01-25 306
二叉树前中后递归和非递归遍历的实现表述形式代码测试结果 表述形式 在这里我在非递归方面前序遍历和中序遍历都提供了两种不同的算法，一种是我自己根据性质和原理写的还有一种就是比较普遍的算法，代码也已经测试过啦，有什么问题可以留言或者私信我，在这里声明一下二叉树的输入的形式,不是顺序输入噢，是按照根左右的形式，空子树用’ ^ ‘代替，会这种表达的小伙伴可以直接跳转到代码方面 举例： 二叉树形态： （有点丑大家不要介意，嘿嘿） 根据根左右，并且空树就用‘^’符号代替的规则： ABD^^^ CE^^ F^^^ 说明
二叉树的前中后递归与非递归遍历算法实现
qq_53439474的博客
11-19 119
(1) 二叉树的前序遍历程序，包含递归、非递归。 (2) 二叉树的中序遍历程序，包含递归、非递归。 (3) 二叉树的后序遍历程序，包含递归、非递归。 代码如下 #include <stdio.h> #include <stdlib.h> // 定义节点 typedef struct Node { char data; struct Node* lChild; struct Node* rChild; } BinTNode; // 根据广义表表示二叉树结构来创建二叉树链表
【数据结构】二叉树----前序、中序、后序遍历非递归和递归的实现
金金金金金的博客
05-03 623
文章目录1、概念2、特殊的二叉树2.1 完全二叉树2.2 满二叉树3、二叉树的性质4、二叉树的存储方式4.1 顺序存储4.2 链式存储5、二叉树实现5.1 顺序存储实现5.2 链式存储实现5.2.1 二叉树的创建5.2.2 前序遍历5.2.3 中序遍历5.2.4 后序遍历5.2.5 层序遍历 1、概念 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。 二叉树的特点： 每个结点最多有两棵子树。 二叉树的子树有左右之分。   2、特殊的二
十四.实现二叉树的先序、中序、后序遍历，包括递归方式和非递归 方式
qq_33604222的博客
05-16 355
【题目】 实现二叉树的先序、中序、后序遍历，包括递归方式和非递归方式 【分析】斜体样式 先序遍历：中左右 非递归的思路：1.建立一个栈存放结点；2.栈中不为空的时候，弹出节点并且打印，相当于打印的是中间的位置；3.先压入的是弹出节点的右节点，在压入左节点（保证弹出的时候左节点先打印）。 中序遍历：左中右 后序遍历：左右中 【先序遍历代码实现】 //1.构造节点结构 public static ...
二叉树全家福 -- 构建二叉树、递归与非递归（先序中序后序）遍历、层次遍历以及层次遍历逐层实现、各节点数加一、查找节点、插入节点、翻转二叉树等
qq_46780256的博客
12-31 673
BTree.h文件： #pragma once #include<iostream> #include<vector> using namespace std; //定义二叉树每个节点的结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) :val(x), left(NULL), right(NULL){}//初始化列表 }; class Tree { privat.
实现二叉树的先序、中序、后序递归遍历和中序非递归遍历，并求叶子几点个数和高度，以菜单的方式输出。
m0_57303885的博客
06-06 897
首先，可以确定先序、中序和后序递归遍历，先建立二叉树进行遍历。 /**二叉树的建立--按照先序方式建立--插入**/ void CreateBiTree(BiTree &T) { char val;//节点的数据类型 scanf("%c",&val); if(val == '#') T = NULL; //null表示为空枝 else { T = (BiTree)malloc(sizeof(BiTreeNod
用C语言编程实现二叉树中序遍历和后续遍历的递归算法和非递归算法。
最新发布
05-05
下面是C语言实现二叉树中序遍历和后序遍历的递归算法和非递归算法的代码示例： ```c #include #include #include #define MAXSIZE 100 // 二叉树结构体 typedef struct TreeNode { int data; struct TreeNode...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值