二叉树的创建与前序、中序和后序的递归与非递归调用

最新推荐文章于 2021-03-21 17:19:07 发布
最新推荐文章于 2021-03-21 17:19:07 发布
阅读量898 收藏 1
点赞数 2
分类专栏： 数据结构与算法的C++实现 文章标签： 链式二叉树 前序 中序 后序 递归与迭代
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014033518/article/details/38844583
版权 
#include<iostream>
#include<string>
#include<vector>
#include<stack>
using namespace std;

typedef char ElemType;

class BiTNode
{
friend class BiTree;
private:
	ElemType data;
	BiTNode *lchild,*rchild; //左右孩子指针
};
class BiTree:public BiTNode
{
public:
	void InputBiTNode();				//输入构成数的结点元素，‘#’表示空串
	void Pre_CreateBiTree(BiTNode *&T);	//先序构造二叉树

	void visit(ElemType e);				//visit函数用于输出结点元素
	void PreOrderTraverse(BiTNode *T);	//先序遍历二叉树T(递归方式)
	void InOrderTraverse(BiTNode *T);	//中序遍历二叉树T(递归方式)
	void PostOrderTraverse(BiTNode *T);	//后序遍历二叉树T(递归方式)

	void Iterator_PreOrderTraverse(BiTNode *T);	//先序遍历二叉树T(非递归方式)
	void Iterator_InOrderTraverse(BiTNode *T);	//中序遍历二叉树T(非方递归式)
	void Iterator_PostOrderTraverse(BiTNode *T);//后序遍历二叉树T(非递归方式)

	void Iterator_PreOrderTraverse2(BiTNode *T);	//先序遍历二叉树T(非递归方式2)
	void Iterator_InOrderTraverse2(BiTNode *T);	//中序遍历二叉树T(非方递归式2)
	void Iterator_PostOrderTraverse2(BiTNode *T);//后序遍历二叉树T(非递归方式2)
private:
	vector<ElemType> elem;
};

void BiTree::InputBiTNode()
{
	ElemType ch;
	cout<<"！！！注意：(1)'#'表示空结点；(2)请在输入的字符串末尾加0,作为输入结束的标志。"<<endl;
	while(cin>>ch&&ch!='0')
	{
		elem.push_back(ch);	//在容器中加入结点元素
	}//while
}//InputBiBode

void BiTree::Pre_CreateBiTree(BiTNode *&T)
{                             
	vector<ElemType>::iterator it=elem.begin();	//迭代器it指向elem的开头
	if(it!=elem.end())
	{
		if(*it=='#')//字符为空格，表示结点不存在
		{
			T=NULL;
			elem.erase(it);	//删除迭代器it指向的elem中的元素，作用是依次删除elem的第一个元素
		}//if
		else
		{
			if(!(T=new BiTNode))
				exit(-1);
			T->data=*it;		//生成根结点
			elem.erase(it);	//删除迭代器it指向的elem中的元素，作用是依次删除elem的第一个元素
			Pre_CreateBiTree(T->lchild);    //构造左子树
			Pre_CreateBiTree(T->rchild);	//构造右子树
		}//else
	}//if
	else	//此时elem为空，使此时T=NULL;,即结束最初的T的结点的赋值
		T=NULL;	
}//Pre_CreateBiTree

void BiTree::PreOrderTraverse(BiTNode *T)
{
	if(T)	//二叉树存在
	{
		visit(T->data);					//访问根结点
		PreOrderTraverse(T->lchild);	//先序遍历左子树
		PreOrderTraverse(T->rchild);	//先序遍历右子树
	}//if
}//PreOrderTraverse

void BiTree::InOrderTraverse(BiTNode *T)
{
	if(T)
	{
		InOrderTraverse(T->lchild);		//中序遍历左子树
		visit(T->data);					//访问根结点
		InOrderTraverse(T->rchild);		//中序遍历右子树
	}//if
}//InOrderTraverse

void BiTree::PostOrderTraverse(BiTNode *T)
{
	if(T)
	{
		PostOrderTraverse(T->lchild);	//后序遍历左子树
		PostOrderTraverse(T->rchild);	//后序遍历右子树
		visit(T->data);					//访问根结点
	}//if
}//PostOrderTraverse

void BiTree::Iterator_PreOrderTraverse(BiTNode *T)
{
	stack<BiTNode*> S;	//用来存储树结点的
	BiTNode *q;
	S.push(T);			//根指针入栈
	while(!S.empty())
	{
		while((q=S.top())&&q)	//先访问结点，再将结点的左子树入栈，栈顶为空指针结束
		{
			visit(q->data);
			S.push(q->lchild);
		}//while
		S.pop();				//空指针出栈
		if(!S.empty())			//由于结点元素已被访问，因此此处只需删除结点，将结点的右结点入栈
		{
			q=S.top();S.pop();	//访问结点时将其从栈中删除
			S.push(q->rchild);
		}//if
	}//while
}//Iterator_PreOrderTraverse

void BiTree::Iterator_InOrderTraverse(BiTNode *T)
{
	stack<BiTNode*> S;	//用来存储树结点的
	BiTNode *q;
	S.push(T);			//根指针入栈
	while(!S.empty())
	{
		while((q=S.top())&&q)	//向左走到尽头
		{
			S.push(q->lchild);
		}//while
		S.pop();				//空指针出栈
		if(!S.empty())			//访问结点，将结点的右结点入栈
		{
			q=S.top();S.pop();	//访问结点时将其从栈中删除
			visit(q->data);
			S.push(q->rchild);	//将右结点入栈
		}//if
	}//while
}//Iterator_InOrderTraverse

void BiTree::Iterator_PostOrderTraverse(BiTNode *T)
{
	stack<BiTNode*> S;	//用来存储树结点的
	BiTNode *q,*point=T;
	S.push(T);			//根指针入栈			
	while(!S.empty())
	{
		while((q=S.top())&&q)	//向左走到尽头
		{
			S.push(q->lchild);
		}//while
		S.pop();				//空指针出栈
		if(!S.empty())
		{
			q=S.top();
			S.push(q->rchild);	//右结点入栈
			if(S.top()==NULL)	//入栈的右结点为空
			{
				S.pop();		//空指针出栈
				point=S.top();S.pop();	//访问根结点并出栈
				visit(point->data);
				while((!S.empty())&&(S.top()->rchild==point))	//栈顶结点的右结点是刚被访问的结点
				{
					point=S.top();S.pop();	//由于该结点的右结点已经被访问，说明完成了左右子树的遍历
					visit(point->data);		//该结点作为子树的根结点则被出栈访问 
				}//while
				if(!S.empty())			
				{
					q=S.top();			//此时栈顶结点的右结点还未入栈
					S.push(q->rchild);	//右结点入栈
				}//if
			}//if
		}//if
	}//while
}//Iterator_PostOrderTraverse

void BiTree::Iterator_PreOrderTraverse2(BiTNode *T)
{
	stack<BiTNode*> S;		//用来存储树结点的
	BiTNode *q=T;
	while(q||(!S.empty()))
	{
		if(q)
		{
			visit(q->data);	//访问根结点
			S.push(q);
			q=q->lchild;	//遍历左子树
		}//if
		else
		{
			q=S.top();S.pop();	//采用先序遍历，结点入栈时已被访问，因此出栈时无需访问
			q=q->rchild;
		}//else
	}//while
}//Iterator_PreOrderTraverse2

void BiTree::Iterator_InOrderTraverse2(BiTNode *T)
{
	stack<BiTNode*> S;		//用来存储树结点的
	BiTNode *q=T;
	while(q||(!S.empty()))
	{
		if(q)				//结点存在
		{
			S.push(q);		//根指针进栈，遍历左子树，
			q=q->lchild;
		}//if
		else				//根指针退栈，访问根结点
		{
			q=S.top();S.pop();
			visit(q->data);
			q=q->rchild;	//遍历右子树
		}//else
	}//while
}//Iterator_InOrderTraverse2

void BiTree::Iterator_PostOrderTraverse2(BiTNode *T)
{
	stack<BiTNode*> S;	//用来存储树结点的
	BiTNode *q=T,*point=T;
	while(q||(!S.empty()))
	{
		if(q)
		{
			S.push(q);	//根指针进栈，遍历左子树
			q=q->lchild;
		}//if
		else
		{
			q=S.top();
			q=q->rchild;			//遍历右子树
			if(!q)					//将要入栈的右子树为空
			{
				point=S.top();S.pop();	//在遍历完左右子树后访问根结点
				visit(point->data);
				while((!S.empty())&&(S.top()->rchild==point))	//栈顶结点的右结点是刚被访问的结点
				{
					point=S.top();S.pop();	//由于该结点的右结点已经被访问，说明完成了左右子树的遍历
					visit(point->data);		//该结点作为子树的根结点则被出栈访问 
				}//while
				if(!S.empty())			
				{
					q=S.top();			//此时栈顶结点的右结点还未入栈
					q=q->rchild;		//右结点入栈
				}//if
			}//if
		}//else
	}//while
}//Iterator_PostOrderTraverse2

void BiTree::visit(ElemType e)
{
	cout<<e;
}//visit

void main()
{
	BiTree BT;
	BiTNode *T;
	BT.InputBiTNode();
	BT.Pre_CreateBiTree(T);

	cout<<"\n"<<"先序遍历（递归）二叉树T："<<endl;
	BT.PreOrderTraverse(T);cout<<endl;
	cout<<"先序遍历（非递归）二叉树T："<<endl;
	BT.Iterator_PreOrderTraverse(T);cout<<endl;
	cout<<"先序遍历（非递归2）二叉树T："<<endl;
	BT.Iterator_PreOrderTraverse2(T);cout<<endl;

	cout<<"\n"<<"中序遍历（递归）二叉树T："<<endl;
	BT.InOrderTraverse(T);cout<<endl;
	cout<<"中序遍历（非递归）二叉树T："<<endl;
	BT.Iterator_InOrderTraverse(T);cout<<endl;
	cout<<"中序遍历（非递归2）二叉树T："<<endl;
	BT.Iterator_InOrderTraverse2(T);cout<<endl;

	cout<<"\n"<<"后序遍历（递归）二叉树T："<<endl;
	BT.PostOrderTraverse(T);cout<<endl;
	cout<<"后序遍历（非递归）二叉树T："<<endl;
	BT.Iterator_PostOrderTraverse(T);cout<<endl;
	cout<<"后序遍历（非递归2）二叉树T："<<endl;
	BT.Iterator_PostOrderTraverse2(T);cout<<endl;
}//main

以下图所示二叉树为例，对中序（非递归）和后序（非递归2）算法栈的入栈和出栈情况进行简单说明：




helenandyoyo
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文彻底搞定二叉树的前序、中序、后序遍历(图解递归非递归)
bigsai
09-22 1万+
前言 大家好，我是bigsai，在数据结构与算法中，二叉树无论是考研、笔试都是非常高频的考点内容，在二叉树中，二叉树的遍历又是非常重要的知识点，今天给大家讲讲二叉树的层序遍历。 这部分很多人可能会但是需要注重一下细节。 前面介绍了二叉排序树的构造和基本方法的实现，遍历也是比较重要的一环，并且二叉树的层序遍历也是bfs的最简单情况，这里我就将二叉树的层序遍历以及常考问题给大家分享一下。 在了解二叉树的遍历之前，需要具备数据结构与算法有队列、递归、栈、二叉树，这些内容咱们前面都有讲过，有这方面知识欠缺的同学可以
Java实现二叉树的前序，中序，后序遍历(迭代，递归两种方法实现)
qswdaw的博客
04-11 4979
前言 二叉树，有深度优先遍历和广度优先遍历，但是这两个概念不止局限于二叉树，它们更是一种抽象的算法思想，决定了访问某些复杂数据结构的顺序。本文主要讲述深度优先遍历的三种方法！ 所谓深度优先，顾名思义，就是偏向于纵深，“一头扎到底”的访问方式。这样说很抽象，下边我们就通过深度优先的前序，中序，后序三种遍历方式，来看一看深度优先把。 三种遍历思想： 前序遍历：根结点 ---> 左子树 ---> 右子树 中序遍历：左子树--->根结点---> 右子树 后序遍历：左子树 ...
二叉树的非递归建立，前序、中序、后序遍历
07-17
关于数据结构实验的二叉树问题
二叉树的基本操作
Health's Box
03-01 447
头文件 #include #include #include using namespace std; 二叉树结点 typedef struct BiTNode { char data; struct BiTNode *lchild, *rchild; //左右孩子 }BiTNode,*BiTree; 建立二叉树
利用先序和中序非递归生成二叉树（java实现）
karaysn的博客
05-22 364
import java.util.LinkedList; import java.util.Queue; import java.util.Stack; class Node{ int number; Node rightChild; Node leftChild; //构造函数 public Node(int number){ this.number=number;
二叉树先序非递归创建及先序中序后序非递归遍历
m0_38105909的博客
04-13 239
#include #include #include using namespace std; #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define STACKINCRMENT 10 typedef struct BiTNode { char data; struct Bi
先序非递归建立二叉树
weixin_30439131的博客
10-07 240
　　大二这么久了，第一个学期课程实在太少，而且全都不是CS的专业课，无奈，若是自己不勤奋一点，过了半年，用不到半年，就又变回小白了。所以自己最近也在重新巩固数据结构的知识。刚好看到二叉树这里，觉得二叉树应用广泛，复习的比较细致。 　　刚开始就是二叉树的建立了，大多数地方都是先序的递归创建，于是便想着试试非递归的代码，倒腾了个把小时，基本上弄出代码了，本渣渣水平有限，有错误的地方，望路过的大神不吝...
二叉树的创建：根据前序中序、中序后序递归创建二叉树
qq_43824618的博客
03-21 1085
根据如图创建二叉树： 先序遍历为： "A B C D E F G H" 中序遍历为： "C B E D F A G H" 后序遍历为： "C E F D B H G A" 代码如 下： #include<stdio.h> #include<stdlib.h> #include<string.h> // memset; #includ...
二叉树的创建(先序创建的)及先序遍历 中序遍历 后序遍历的递归和非递归实现
Hmyy的博客
10-04 1640
1.首先是关于二树结点的设计 typedef struct TreeNode *PtrToNode; typedef PtrToNode BinTree; struct TreeNode {     char data; // 结点数据，假设是字符     BinTree left; // 指向左子树     BinTree right; // 指向右子树 };
链表先序建立二叉树，得到中序后序输出，递归和非递归实现(C++代码加设计报告)
07-15
在本课程设计中，我们将探讨如何使用C++编程语言来构建和操作二叉树，特别是通过先序遍历建立二叉树以及非递归方式实现中序遍历。这一过程涉及到了数据结构中的核心概念——二叉链表，以及递归和非递归算法的应用。 ...
C语言二叉树常见操作详解【前序,中序,后序,层次遍历及非递归查找,统计个数,比较,求深度】
08-27
在本文中，我们将详细介绍C语言二叉树的基本概念、存储结构、遍历方法、非递归查找、统计个数、比较和求深度等操作技巧。 一、基本概念 二叉树是一种树形结构，每个结点最多有两棵子树，左子树和右子树，次序不...
关于二叉树前序和后序的非递归遍历算法.rar
02-18
标题"关于二叉树前序和后序的非递归遍历算法"指的是不使用递归函数来实现二叉树的前序和后序遍历。递归方法虽然直观，但在处理大型二叉树时可能会导致栈溢出，因此非递归方法是一个更优的选择。 **前序遍历**是...
二叉树先序、中序、后序、层序遍历非递归实现
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
数据结构: 非递归先序创建二叉树及其先序，中序和后序遍历
-_-
05-31 711
非递归先序创建二叉树及其先序，中序和后序遍历：#include&lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #define MAXSIZE 100 typedef struct BTNode { char data; struct BTNode *lchild, *rchild; } BT...
二叉树的创建和先序，中序，后序，递归，非递归遍历
BruceBaoZhiqiang的专栏
01-06 889
#include "stdafx.h"#includeusing namespace std;#define ERROR 0#define OK 1#define SMAXSIZE 100//二叉树的创建typedef struct BiTNode{ char data; struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;//存储二叉树的栈BiTree
【数据结构】-二叉树的先序、中序、后序遍历-非递归实现
RunningSnail的博客
08-07 1449
二叉树的遍历-先序、中序、后序1.头文件及类型定义2.二叉链表结点类型定义3.函数声明4.基本操作4.1 先序建立二叉树4.2 打印结点4.3 先序遍历4.4 中序遍历4.5 后序遍历4.6 main函数4.7 测试4.7.1 二叉树结构4.7.2 测试结果5.小结 1.头文件及类型定义 #include<stdio.h> #include<stdlib.h> #define ElemType char 2.二叉链表结点类型定义 //二叉链表结点类型定义 typedef struc
遍历二叉树的各种操作（非递归遍历）
leo1949asd的专栏
05-02 520
转载请标明出处，原文地址：http://blog.csdn.net/hackbuteer1/article/details/6583988         先使用先序的方法建立一棵二叉树，然后分别使用递归与非递归的方法实现前序、中序、后序遍历二叉树，并使用了两种方法来进行层次遍历二叉树，一种方法就是使用STL中的queue，另外一种方法就是定义了一个数组队列，分别使用了front和rea
二叉树的前序，中序非递归实现
Everything can be done!
05-27 409
整了一下前序和中序的实现，后序的非递归遍历的话先占个坑。#include&lt;bits/stdc++.h&gt; using namespace std; typedef long long ll; const int maxn = 2e5 + 100; struct TreeNode { int x; TreeNode *left,*right; TreeNod...
银行业务的模拟程序
慢慢的专栏
08-01 5846
银行业务的模拟程序： 假设某银行有四个窗口对外接待客户，且每个窗口在某时刻只能接待一位客户，客户在银行工作时间内进入银行后选择最短的一队进行排队等候。现在编制一个程序以模拟银行的这种业务活动并计算一天中客户在银行逗留的时间。 前期准备： 1）客户逗留时间=客户离开银行时间-客户进入银行时间 2）称客户到达银行和客户离开银行这两个时刻发生的事情为“事件” 3）将上述所有事件按照先后顺序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值