c++ 二叉查找树 非递归(先序、中序、后序)遍历
关键词:
c++ 二叉查找树 非递归(先序、中序、后序)遍历
<smarttagtype name="RTX" namespaceuri="Tencent"><!--[if gte mso 9]><xml>
<o:DocumentProperties>
<o:Author>FtpDown</o:Author>
<o:LastAuthor>FtpDown</o:LastAuthor>
<o:Revision>4</o:Revision>
<o:TotalTime>16</o:TotalTime>
<o:Created>2006-06-04T07:11:00Z</o:Created>
<o:LastSaved>2006-06-04T07:12:00Z</o:LastSaved>
<o:Pages>1</o:Pages>
<o:Words>505</o:Words>
<o:Characters>2884</o:Characters>
<o:Company>www.ftpdown.com</o:Company>
<o:Lines>24</o:Lines>
<o:Paragraphs>6</o:Paragraphs>
<o:CharactersWithSpaces>3383</o:CharactersWithSpaces>
<o:Version>11.5606</o:Version>
</o:DocumentProperties>
</xml><![endif]--><!--[if gte mso 9]><xml>
<w:WordDocument>
<w:SpellingState>Clean</w:SpellingState>
<w:GrammarState>Clean</w:GrammarState>
<w:PunctuationKerning />
<w:DrawingGridVerticalSpacing>7.8 磅</w:DrawingGridVerticalSpacing>
<w:DisplayHorizontalDrawingGridEvery>0</w:DisplayHorizontalDrawingGridEvery>
<w:DisplayVerticalDrawingGridEvery>2</w:DisplayVerticalDrawingGridEvery>
<w:ValidateAgainstSchemas />
<w:SaveIfXMLInvalid>false</w:SaveIfXMLInvalid>
<w:IgnoreMixedContent>false</w:IgnoreMixedContent>
<w:AlwaysShowPlaceholderText>false</w:AlwaysShowPlaceholderText>
<w:Compatibility>
<w:SpaceForUL />
<w:BalanceSingleByteDoubleByteWidth />
<w:DoNotLeaveBackslashAlone />
<w:ULTrailSpace />
<w:DoNotExpandShiftReturn />
<w:AdjustLineHeightInTable />
<w:BreakWrappedTables />
<w:SnapToGridInCell />
<w:WrapTextWithPunct />
<w:UseAsianBreakRules />
<w:DontGrowAutofit />
<w:UseFELayout />
</w:Compatibility>
<w:BrowserLevel>MicrosoftInternetExplorer4</w:BrowserLevel>
</w:WordDocument>
</xml><![endif]--><!--[if gte mso 9]><xml>
<w:LatentStyles DefLockedState="false" LatentStyleCount="156">
</w:LatentStyles>
</xml><![endif]--><!--[if !mso]><
classid="clsid:38481807-CA0E-42D2-BF39-B33AF135CC4D" id=ieooui></object>
<style>
st1\:*{behavior:url(#ieooui) }
</style>
<![endif]--><!--[if gte mso 10]>
<style>
/* Style Definitions */
table.MsoNormalTable
{mso-style-name:普通表格;
mso-tstyle-rowband-size:0;
mso-tstyle-colband-size:0;
mso-style-noshow:yes;
mso-style-parent:"";
mso-padding-alt:0cm 5.4pt 0cm 5.4pt;
mso-para-margin:0cm;
mso-para-margin-bottom:.0001pt;
mso-pagination:widow-orphan;
font-size:10.0pt;
font-family:"Times New Roman";
mso-ansi-language:#0400;
mso-fareast-language:#0400;
mso-bidi-language:#0400;}
</style>
<![endif]--><!--[if gte mso 9]><xml>
<o:shapedefaults v:ext="edit" spidmax="2050" />
</xml><![endif]--><!--[if gte mso 9]><xml>
<o:shapelayout v:ext="edit">
<o:idmap v:ext="edit" data="1" />
</o:shapelayout></xml><![endif]--></smarttagtype>
#include <iostream.h>
#include <malloc.h>
#include <stack>
#include <list>
using namespace std;
typedef int ElemType;
typedef struct treeT
{
ElemType key;
struct treeT* left;
struct treeT* right;
}treeT, *pTreeT;
class BITree{
public:
pTreeT Insert(ElemType target, pTreeT* <rtx w:st="on"><span class="SpellE">pp</span></rtx>Tree);
void PreOrder(pTreeT root);
void lev_Order(pTreeT);
void InOrderNoRec(pTreeT root);
void PreOrderNoRec(pTreeT root);
void PosOrderNoRec(pTreeT root);
};
;
pTreeT BITree::Insert(ElemType target, pTreeT* <rtx w:st="on"><span class="SpellE">pp</span></rtx>Tree)
{
pTreeT Node;
Node = *<rtx w:st="on"><span class="SpellE">pp</span></rtx>Tree;
if (NULL == Node)
{
Node=(pTreeT)malloc(sizeof(treeT));
Node->key = target;
Node->left = NULL;
Node->right = NULL;
*<rtx w:st="on"><span class="SpellE">pp</span></rtx>Tree=Node;
return *<rtx w:st="on"><span class="SpellE">pp</span></rtx>Tree ;
}
if (Node->key == target) //不允许出现相同的元素
{
return NULL;
}
else if (Node->key > target) //向左
{
return Insert(target, &Node->left);
}
else
{
return Insert(target, &Node->right);
}
}
void BITree::PreOrder(pTreeT root)
{
if(root!=NULL)
{
cout<<root->key<<",";
PreOrder(root->left);
PreOrder(root->right);
}
}
void BITree::lev_Order(pTreeT root)
{
list<pTreeT> list1;
pTreeT p;
list1.push_back(root);
while(!list1.empty())
{
p=(pTreeT)list1.front();
list1.pop_front();
cout<<p->key<<",";
if(p->left!=NULL)
list1.push_back(p->left);
if(p->right!=NULL)
list1.push_back(p->right);
}
}
void BITree::InOrderNoRec(pTreeT root)
{
stack<pTreeT > s;
while ((NULL != root) || !s.empty())
{
if (NULL != root)
{
s.push(root);
root = root->left;
}
else
{
root = s.top();
cout<<root->key<<",";
s.pop();
root = root->right;
}
}
}
void BITree::PreOrderNoRec(pTreeT root)
{
stack<pTreeT > s;
while ((NULL != root) || !s.empty())
{
if (NULL != root)
{
cout<<root->key<<",";
s.push(root);
root = root->left;
}
else
{
root = s.top();
s.pop();
root = root->right;
}
}
}
void BITree::PosOrderNoRec(pTreeT root)
{
stack<pTreeT> st;
pTreeT p = root;
pTreeT pre = NULL;//pre表示最近一次访问的结点
while(p || st.size()!=0)
{
//沿着左孩子方向走到最左下 。
while(p)
{
st.push(p);
p = p->left;
}
//get the top element of the stack
p = st.top();
//如果p没有右孩子或者其右孩子刚刚被访问过
if(p->right == NULL || p->right == pre)
{
//visit this element and then pop it
cout<< p->key<<",";
st.pop();
pre = p;
p = NULL;
}
else
{
p = p->right;
}
}
}
测试代码:
#include <iostream.h>
#include "Tree.h"
#include <malloc.h>
#include <assert.h>
void main()
{
BITree bitree;
//int i;
pTreeT root = NULL;
bitree.Insert(10, &root);
bitree.Insert(8, &root);
bitree.Insert(7, &root);
bitree.Insert(9, &root);
bitree.Insert(12, &root);
bitree.Insert(11, &root);
bitree.Insert(13, &root);
//递归先序遍历
cout<<"递归先序遍历"<<endl;
bitree.PreOrder(root);
//层次遍历(队列实现)
cout<<endl<<"层次遍历(队列实现)"<<endl;
bitree.lev_Order(root);
//非递归先序遍历
cout<<endl<<"非递归先序遍历"<<endl;
bitree.PreOrderNoRec(root);
//非递归中序遍历
cout<<endl<<"非递归中序遍历"<<endl;
bitree.InOrderNoRec(root);
//非递归后序遍历
cout<<endl<<"非递归后序遍历"<<endl;
bitree.PosOrderNoRec(root);
}
分享到:
相关推荐
在C++编程中,二叉查找树(Binary Search Tree,简称BST)是一种常见的数据结构,它具有以下特性:对于任意节点,其左子树中的所有节点的值都小于该节点的值,右子树中所有节点的值都大于该节点的值。这种性质使得...
插入二叉排序树结点,先序递归遍历,中序递归遍历,中序非递归遍历,后序递归遍历,层次遍历,查找关键字,交换左右子树,二叉排序树的深度,二叉排序树的叶子结点数
非递归遍历分为先序、中序和后序遍历。 **3.1 先序遍历** 先序遍历的顺序为“根→左子树→右子树”。 ```cpp void PreorderTraversal(TreeNode* root) { if (root == nullptr) return; stack*> s; s.push(root...
主要有三种遍历方式:先序遍历、中序遍历和后序遍历。 1. **先序遍历**:访问根节点 -> 遍历左子树 -> 遍历右子树。在递归实现中,它会看起来像这样: ```cpp void preorderTraversal(TreeNode* root) { if ...
在本文中,我们将深入探讨二叉树的概念、它的类型、以及如何使用C++进行实现,包括先序遍历、中序遍历和后序遍历。 首先,我们来理解二叉树的基本概念。二叉树是由节点(每个节点包含一个值)和边(连接节点的关系...
例如,先序遍历中,节点按根节点、左子树、右子树的顺序访问,中序遍历则是左子树、根节点、右子树,后序遍历是左子树、右子树、根节点的顺序。层次遍历则利用队列按层次从上至下遍历树的每一个节点。这些遍历方法在...
树的遍历主要有三种方法:先序遍历、中序遍历和后序遍历。它们都是深度优先遍历方法,区别在于访问节点的顺序不同。 - 先序遍历:先访问根节点,然后访问左子树,最后访问右子树。 - 中序遍历:先访问左子树,然后...
实现了二叉树的多种操作:添加、删除、拷贝、清空、树深度计算、父节点、兄弟节点获取、先中后序递归及非遍历、按层次遍历、中序迭代器(非递归算法)、节点查找、先序和中序序列重建二叉树、数组和二叉链表存储结构...
本次课程设计的主要内容为建立一个二叉树,并实现其先序、中序和后序遍历。此外,还需要计算并输出二叉树的叶子节点数量。 - **先序遍历**:首先访问根节点,然后遍历左子树,最后遍历右子树。 - **中序遍历**:先...
4. **非递归先序遍历**(Non-Recursive PreOrder Traversal):使用栈辅助实现,先将根节点压入栈,然后不断从栈顶弹出节点访问,并将其右子节点压入栈,直到栈空。在代码中,通过`FeiPreOrderTraverse`函数实现,...
- 实现二叉树的先序、中序、后序遍历,递归或非递归实现。非递归实现需用栈,包括初始化、判断栈空、出栈和入栈操作。 - 定义队列的顺序存储结构,并实现入队、出队、初始化队列和判断队列是否为空等基本操作。...
例如,非递归中序遍历可以使用栈辅助实现: ```cpp void inorderTraversal(TreeNode* root) { std::stack*> s; TreeNode* curr = root; while (curr || !s.empty()) { while (curr) { s.push(curr); curr = ...
在二叉树中,有三种基本的遍历方式:先序遍历、中序遍历和后序遍历。这三种遍历方法分别以不同的顺序访问节点。 1. **先序遍历**(前序遍历):访问根节点 -> 遍历左子树 -> 遍历右子树。 2. **中序遍历**:遍历左...
通常,这些函数会涉及递归操作,以遍历树的各个部分,并创建或解析相应的二叉树结构。递归函数可能会包括插入新节点、删除节点、以及根据遍历顺序构造二叉树等功能。 此外,二叉树的遍历方式有三种:前序遍历(根-...
遍历二叉树有三种主要方法:前序遍历(根-左-右)、中序遍历(左-根-右)和后序遍历(左-右-根),这些遍历方法对于理解树的结构和执行特定操作非常有用。 "构建二叉树的二叉链表存储结构.doc" 文件可能详细介绍了...
二叉树先序、中序、后序遍历的递归算法 二叉树中序遍历的非递归算法 二叉树层次遍历的非递归算法 求二叉树的深度(后序遍历) 建立树的存储结构 求树的深度 图 输入任意的一个网,用普里姆(Prim)算法构造最小生成树。 ...
- 后序遍历(左-右-根):先遍历左右子树,再访问根节点。 - 层序遍历(广度优先搜索):使用队列,从根节点开始,按层逐个访问所有节点。 3. **非递归遍历**: - 使用栈或队列实现,避免了递归带来的调用栈开销...
线索二叉树是一种特殊的二叉树结构,它的设计目的是为了在非递归方式下更高效地查找二叉树中节点的前驱和后继。在普通的二叉链表中,节点仅通过左右子节点来表示父子关系,但无法直接获取到在某种遍历顺序(如前序、...
`createBiTree`函数使用先序遍历的方式构建二叉树,而遍历函数如`FirstOrderTraverse`、`InOrderTraverse`和`LastOrderTraverse`则是递归地遍历树的各个节点。此外,`LevelTraverse`函数利用队列实现了层次遍历,这...