程序二叉树的四种遍历方法和两种求深度的方法
二叉树的四种遍历方法和两种求深度的方法
用到了以前学的栈和队列的知识，也算是一种复习。不过用到栈来求深度的时候，改变了二叉树，不知道如何去避免？
// 二叉树.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"
typedef struct BiTNode{ //二叉树结构
int data;
struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;
#define STACK_INIT_SIZE 100
#define STACKINGMENT 10
int CreateBiTree( BiTNode **T ) //用先序顺序建立二叉树
{
char c;
if( (c = getchar()) == '#')
*T = NULL;
else
{
if(!(*T = (BiTree)malloc(sizeof(BiTNode))))
{
printf("ERROR!");
return 0;
}
(*T)->data = c;
CreateBiTree(&(*T)->lchild);
CreateBiTree(&(*T)->rchild);
}
return 0;
}
int PrintfElement( int e )
{
printf("%c",e);
return 1;
}
int PreOrderTraverse(BiTree T,int (* PrintfElement)(int e)) //先序遍历二叉树的递归方法
{
if(T) //访问根结点
{
if(PrintfElement(T->data))
if(PreOrderTraverse(T->lchild,PrintfElement)) //先序遍历左子树
if(PreOrderTraverse(T->rchild,PrintfElement)) //先序遍历右子树
return 1;
return 0;
}
else
return 1;
}
int InOrderTraverse(BiTree T,int (*PrintfElement)(int)) //中序遍历二叉树的递归方法
{
if(T)
{
if(InOrderTraverse(T->lchild, PrintfElement))
if(PrintfElement(T->data))
if(InOrderTraverse(T->rchild, PrintfElement))
return 1;
return 0;
}
else
return 1;
}
int PostOrderTraverse(BiTree T, int (*PrintfElement)(int) ) //后序遍历二叉树的递归方法
{
if(T)
{
if(PostOrderTraverse(T->lchild, PrintfElement))
if(PostOrderTraverse(T->rchild, PrintfElement))
if(PrintfElement(T->data))
return 1;
return 0;
}
else
return 1;
}
/*typedef struct{ //栈
BiTree * base;
BiTree * top;
int stacksize;
}SqStack;
int InitStack(SqStack **s) //建立空栈
{
(*s)->base = (BiTree*)malloc(STACK_INIT_SIZE * sizeof(BiTNode*));
if(!((*s)->base))
return 0;
(*s)->top = (*s)->base;
(*s)->stacksize = (*s)->stacksize;
return 0;
}
int Push(SqStack *s, BiTree T) //压栈
{
if(s->top - s->base >= STACK_INIT_SIZE)
{
s->base = (BiTree*)realloc(s->base,(STACK_INIT_SIZE + STACKINGMENT) + sizeof(BiTNode*));
s->top = s->base + STACK_INIT_SIZE;
s->stacksize += STACK_INIT_SIZE;
}
*s->top++ = T;
return 0;
}
BiTree Pop(SqStack *s,BiTree T) //出栈, 后返回栈顶元素
{
if(s->base == s->top)
{
printf("已空！");
return 0;
}
T = * (-- s->top -1);
return T;
}
// 此方法过后二叉树就被改变了。
int DeepBiTree(BiTree T) //二叉树的深度{
BiTree p = T;
SqStack *s, a;
int deep = 1,max = 0,k = 0,b = -2,i = 0,j = 0;
s = &a;
InitStack(&s);
Push(s, T);
if(T->rchild == NULL)
b++;
while(b)
{
if(p->lchild)
{
if(0 == k)
{
p = p->lchild;
j = 1; //表记走过左子树
}
else
{
p = p->rchild;
k = 0;
i = 1;
}
Push(s,p);
deep++;
if(deep > max)
max = deep;
}
else
{
if(p->rchild != NULL)
{
i = 1;
p = p->rchild;
Push(s,p);
deep++;
if(deep > max)
max = deep;
}
else
{
p = Pop(s,p);
deep--;
k = 1;
if(i) //把走过的子树置为空，以后不再走
p->rchild = NULL;
if(j)
p->lchild = NULL;
i = j = 0;
}
}
if(p == T)
b++;
}
free(s->base);
return max;
}*/
int DeepBiTree(BiTree T) //求二叉树的深度
{
int ldeep,rdeep;
if(!T)
return 0; //空二叉子树深度为0
else
{
ldeep = DeepBiTree(T->lchild); //先序遍历二叉树谨记：递归是把问题分解成一个最小的单元，例如这里求二叉树的深度就是
rdeep = DeepBiTree(T->rchild); //左二叉子树的深度和右二叉子树的深度作比较，取大的那个加一就是此二叉树的深度。
}
if(ldeep > rdeep) //ldeep就是每个“二叉树”的左子树深度。 return ldeep + 1; //rdeep就是每个“二叉树”的右子树深度。else
return rdeep + 1;
}
typedef struct QNode{
BiTree data;
struct QNode *next;
}QNode, *QueuePtr;
typedef struct{
QueuePtr front;
QueuePtr rear;
}LinkQueue;
int InitQueue(LinkQueue **Q) //建立空队列
{
(*Q)->rear = (*Q)->front = (QueuePtr)malloc(sizeof(QNode));//给对头分配空间
if(!(*Q)->front)
return 0;
(*Q)->front->next= NULL; //队尾指向空
return 0;
}
int DestoryQueue(LinkQueue *Q)
{
while(Q->front) //对头不为空则继续删除
{
Q->rear = Q->front->next; //保留对头后一个队员，留出对头以便删除
free(Q->front); //删除原对头结点
Q->front = Q->rear; //指向新对头
}
return 0;
}
int EnQueue(LinkQueue *Q, BiTree T) //插入新队员切记队列在队尾插入。
{
QueuePtr p;
if(!(p = (QueuePtr)malloc(sizeof(QNode)))) //生成新结点(不要搞错结点的类型)
return 0;
p->data = T; //给新结点赋值
p->next = NULL; //新结点指向空
Q->rear->next = p; //队尾指向新结点Q->rear = p; //新队尾既是刚插入的结点
return 0;
}
BiTree DeQueue(LinkQueue *Q, BiTree T) //在对头删除{
QueuePtr p = Q->front->next; // 辅助指针标记要删除的队员
if(Q->front == Q->rear) //空队列不予删除{
printf("队列已空，无法删除！\n");
return 0;
}
T = p->data; //提取要删除的队员
Q->front->next = p->next; //删除对头结点
if(Q->rear == p) //若队列已空
Q->rear = Q->front; //则对头等于队尾
free(p); //删除结点
return T;
}
//队列使用注意：在对头删除，在队尾插入，对头没有指向数据，而队尾有，空队列对头等于队尾。
int LevelOrderTraverse(BiTree T, int (*PrintfElement)(int)) //层序遍历二叉树
{
LinkQueue *Q, a;
Q = &a;
BiTree p = T;
InitQueue(&Q);
if(!T) //空二叉树结束
return 0;
PrintfElement(p->data); //首先输出根结点
if(p->lchild) //若左孩子存在则把左孩子插入队列
EnQueue(Q, p->lchild);
if(p->rchild) //若右孩子存在则把右孩子插入队列
EnQueue(Q, p->rchild);
while(Q->front != Q->rear) //队列不为空
{
p = DeQueue(Q, p); //删除对头
PrintfElement(p->data); //输出结点
if(p->lchild) //同上
EnQueue(Q, p->lchild);
if(p->rchild)
EnQueue(Q, p->rchild);
}
DestoryQueue(Q); //销毁队列
return 0;
}
int main()
{
int (*p)(int) ; //函数类型指针
int deep;
BiTree T;
BiTNode s;
T = &s;
p = PrintfElement;
printf("输入字符建立二叉树："); CreateBiTree( &T );
printf("先序遍历输出二叉树:"); PreOrderTraverse(T,p);
printf("\n中序遍历输出二叉树:"); InOrderTraverse(T, p);
printf("\n后序遍历输出二叉树:"); PostOrderTraverse(T,p);
deep = DeepBiTree(T);
printf("\n二叉树的深度：%d\n",deep); printf("层序遍历输出二叉树;"); LevelOrderTraverse(T,p);
return 0;
}
创建一个二叉树并输出三种遍历结果
实验报告 课程名称数据结构 实验项目实验三--创建一个二叉树并输出三种遍历结果 系别■计算机学院 _________________ 专业_______________ 班级/学号_____________ 学生姓名___________ 实验日期— 成绩______________________________ 指导 教师
实验题目：实验三创建一个二叉树并输出三种遍历结果 实验目的 1）掌握二叉树存储结构； 2）掌握并实现二叉树遍历的递归算法和非递归算法; 3）理解树及森林对二叉树的转换; 4）理解二叉树的应用一哈夫曼编码及WPL计算。 实验内容 1）以广义表或遍历序列形式创建一个二叉树，存储结构自选； 2）输出先序、中序、后序遍历序列； 3）二选一应用题：1）树和森林向二叉树转换；2）哈夫曼编码的应用问题。 题目可替换上述前两项实验内容） 设计与编码 1）程序结构基本设计框架 （提示：请根据所选定题目，描述程序的基本框架，可以用流程图、界面描述图、 框图等来表示） 2）本实验用到的理论知识遍历二叉树，递归和非递归的方法 （应用型
(提示：总结本实验用到的理论知识，实现理论与实践相结合。总结尽量简明扼要，并与本次实验密切相关，要求结合自己的题目并阐述自己的理解和想法) 3) 具体算法设计 1) 首先，定义二叉树的存储结构为二叉链表存储，每个元素的数 据类型Elemtype,定义一棵二叉树，只需定义其根指针。 2) 然后以递归的先序遍历方法创建二叉树，函数为CreateTree()，在输 入字符时要注意,当节点的左孩子或者右孩子为空的时候,应当输入一 个特殊的字符(本算法为“ #”),表示左孩子或者右孩子为空。 3) 下一步,创建利用递归方法先序遍历二叉树的函数,函数为 PreOrderTreeQ,创建非递归方法中序遍历二叉树的函数，函数为 InOrderTree()，中序遍历过程是：从二叉树的根节点开始，沿左子树 向下搜索，在搜索过程将所遇到的节点进栈；左子树遍历完毕后，从 栈顶退出栈中的节点并访问；然后再用上述过程遍历右子树，依次类 推，指导整棵二叉树全部访问完毕。创建递归方法后序遍历二叉树的 函数，函数为LaOrderTree()。 (提示：该部分主要是利用C、C++ 等完成数据结构定义、设计算法实现各种操作，可以用列表分步形式的自然语言描述，也可以利用流程图等描述) 4) 编码 #include
二叉树的各种算法
二叉树的各种算法.txt男人的承诺就像80岁老太太的牙齿，很少有真的。你嗜烟成性的时候，只有三种人会高兴，医生你的仇人和卖香烟的。 /*用函数实现如下二叉排序树算法： （1）插入新结点 （2）前序、中序、后序遍历二叉树 （3）中序遍历的非递归算法 （4）层次遍历二叉树 （5）在二叉树中查找给定关键字(函数返回值为成功1,失败0) （6）交换各结点的左右子树 （7）求二叉树的深度 （8）叶子结点数 Input 第一行：准备建树的结点个数n 第二行：输入n个整数，用空格分隔 第三行：输入待查找的关键字 第四行：输入待查找的关键字 第五行：输入待插入的关键字 Output 第一行：二叉树的先序遍历序列 第二行：二叉树的中序遍历序列 第三行：二叉树的后序遍历序列 第四行：查找结果 第五行：查找结果 第六行~第八行：插入新结点后的二叉树的先、中、序遍历序列 第九行：插入新结点后的二叉树的中序遍历序列(非递归算法) 第十行：插入新结点后的二叉树的层次遍历序列 第十一行~第十三行：第一次交换各结点的左右子树后的先、中、后序遍历序列 第十四行~第十六行：第二次交换各结点的左右子树后的先、中、后序遍历序列 第十七行：二叉树的深度 第十八行：叶子结点数 */ #include "stdio.h" #include "malloc.h" #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0
#define INFEASIBLE -1 #define OVERFLOW -2 typedef int Status; typedef int KeyType; #define STACK_INIT_SIZE 100 // 存储空间初始分配量 #define STACKINCREMENT 10 // 存储空间分配增量 #define MAXQSIZE 100 typedef int ElemType; typedef struct BiTNode{ ElemType data; struct BiTNode *lchild,*rchild;//左右孩子指针 } BiTNode,*BiTree; Status SearchBST(BiTree T,KeyType key,BiTree f,BiTree &p) { if(!T){p=f;return FALSE;} else if(key==T->data){p=T;return TRUE;} else if(key
数据结构求二叉树深度和度为2的节点个数代码实现
/* 求二叉树的深度 求二叉树度为2的节点个数 附带详细注释 */ # include
T = NULL; //如果是#，说明是一颗空树 } else { //节点有值，则创建这个节点 T = ( PTNODE )malloc( sizeof( NODE ) ); if( NULL == T ) { printf( "节点动态空间分配失败\n" ); return ERROR; } T -> data = data; CreatTree( T -> lchild ); CreatTree( T -> rchild ); } return OK; } /* 先序遍历二叉树 同样的，这一段代码也同样是写烂了 写这段代码的作用是为了检查刚刚那个二叉树生成了没*/ Status InOrderTraveler( PTNODE &T ) { if( NULL != T ) { printf( "%c", T -> data ); InOrderTraveler( T -> lchild ); InOrderTraveler( T -> rchild ); } return OK; } /* 求出二叉树的深度，这个才是今天的猪脚 */ int DeepTree( PTNODE & T ) { //设置两个整型变量，用于接收左子树和右子树的深度int LDeep, RDeep; if( NULL == T )
数据结构C语言实现二叉树三种遍历
实验课题一：将下图中得二叉树用二叉链表表示： 1用三种遍历算法遍历该二叉树，给出对应得输出结果; 2写一个函数对二叉树搜索,若给出一个结点，根据其就是否属于该树，输出tｒｕe或者f ａｌse。 3写函数完成习题4、31(Ｃ＋+版)或4、2８（C版教科书）。 #iｎclｕde "stdio、h＂ ＃incluｄe”mallｏc、h" typedｅfｓtruct BｉTＮode ｛ cｈar data; sｔrucｔBiTＮode *lｃｈild,*rｃhiｌd; }ＢiTＮodｅ，*BiTrｅe； BｉＴree Creaｔe（BｉTｒeｅT) ｛ char ch； ch=getchａｒ(）; ｉｆ(ch=='#’） T=NULL; elｓe { T=(BiＴNode *）maｌloc(sｉｚｅｏf（ＢiTNｏｄe)）; Ｔ-〉data=ｃh； Ｔ-＞lｃｈiｌd=Creaｔe(T—〉lchilｄ); T—〉rchild=Creａte(Ｔ－〉rchｉld）； ｝ retuｒn Ｔ； } ｉnt node(BiＴrｅe Ｔ) { int sum1=0，a,b; ?iｆ（T) ｛ if（Ｔ！=ＮUＬL） ??sｕm1++;
?ａ=ｎode（Ｔ->lchiｌd); sｕm1＋=ａ； b=node(T—>rchｉld)； sum1+=b; ?} ｒetｕrn sum1； } int mｎode（BiTree T） { ?int sum２=0,ｅ，ｆ； if（T) { ?ｉf（（T->lcｈiｌd!=NULL）&＆(T－〉rchild!=NULL）)?sum2++； ?e=ｍnoｄｅ（Ｔ－〉lchild); suｍ2＋=e; f＝mnoｄｅ（T－〉rchｉｌd)； sum２+=f； ?｝ retｕrn sum2; ｝ void Preorｄer（BiTree T) { ｉf(Ｔ） { pｒintf（＂%c”，T－>daｔa)； Ｐreoｒder(Ｔ—>lchiｌｄ）； Ｐreorder（T－〉rchｉld）； ｝ } iｎt Sumｌeaｆ（BiTｒｅe T) { int suｍ=0,m，n; if（T） { if((！T-〉lchild）&&（!T-〉rｃhiｌd)) sum++； m=Ｓuｍleaf（T－>lchｉld)； suｍ+=m； n=Sumleaf(T—＞rｃhｉｌd); suｍ+＝ｎ； ｝ retuｒn ｓum； }
求树和二叉树的深度题目及源程序代码
树和二叉树 以下问题要求统一在一个大程序里解决。 10、按先序遍历的扩展序列建立二叉树的存储结构 11、二叉树先序、中序、后序遍历的递归算法 12、二叉树中序遍历的非递归算法 13、二叉树层次遍历的非递归算法 14、求二叉树的深度(后序遍历) 15、建立树的存储结构 16、求树的深度 17、 源程序代码： // tree.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include "stdio.h" #include "stdlib.h" #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -1 typedef char TElemType; // 元素数据类型 typedef int Status; /* 二叉链表储存结构*/ typedef struct BiTNode { TElemType data; struct BiTNode *lchild, *rchild; }BiTNode, *BiTree; bool CreateBiTree(BiTree &T) { //先序序列建立二叉树 char ch; scanf("%c",&ch); if (ch=='*') T = NULL;
else { if (!(T = (BiTNode *)malloc(sizeof(BiTNode)))) return ERROR; T->data = ch; CreateBiTree(T->lchild); CreateBiTree(T->rchild); } return OK; } Status PrintElement(TElemType e) { // 访问函数 printf("%c", e); return OK; } Status PreOrderTraverse(BiTree T, Status(*Visit)(TElemType)) { //先序遍历二叉树的递归算法 if (T) { if (Visit(T->data)) if (PreOrderTraverse(T->lchild, Visit)) if (PreOrderTraverse(T->rchild, Visit)) return OK; return ERROR; }else return OK; } Status InOrderTraverse(BiTree T, Status(*Visit)(TElemType)) { //中序遍历二叉树的递归算法 if (T) { if (InOrderTraverse(T->lchild, Visit)) if (Visit(T->data)) if (InOrderTraverse(T->rchild, Visit)) return OK; return ERROR; }else return OK;
C语言实现二叉树的前序遍历(递归)
C语言实现二叉树的前序遍历算法实现一： #include
#include
二叉树的基本参数计算
/*二叉树的基本参数计算*/ #include
t=(BiTNode*)malloc(sizeof(BiTNode)); t->data=T->data; t1=swap(T->lchild); //交换左右子树 t2=swap(T->rchild); t->lchild=t2; t->rchild=t1; } return(t); } //求树的叶子结点数 int leafs(BiTree T) { int num1,num2; if(T==NULL) return 0; else if(T->lchild==NULL&&T->rchild==NULL) return 1; else { num1=leafs(T->lchild); num2=leafs(T->rchild); return (num1+num2); } } //求二叉树的深度 int Depth(BiTNode *T) { int dep1,dep2; if(T==NULL) return(0); else { dep1=Depth(T->lchild); dep2=Depth(T->rchild); if(dep1>dep2) return(dep1+1); else return(dep2+1); } } //按广义表形式输出二叉树 void Disptree(BiTNode *T)
二叉树遍历C语言(递归,非递归)六种算法
数据结构（双语） ——项目文档报告用两种方式实现表达式自动计算 专业： 班级： 指导教师： 姓名： 学号：
目录 一、设计思想 (01) 二、算法流程图 (02) 三、源代码 (04) 四、运行结果 (11) 五、遇到的问题及解决 (11) 六、心得体会 (12)
一、设计思想 二叉树的遍历分为三种方式，分别是先序遍历，中序遍历和后序遍历。先序遍历实现的顺序是：根左右，中序遍历实现的是：左根右，后续遍历实现的是：左右根。根据不同的算法分，又分为递归遍历和非递归遍历。 递归算法： 1．先序遍历：先序遍历就是首先判断根结点是否为空，为空则停止遍历，不为空则将左子作为新的根结点重新进行上述判断，左子遍历结束后，再将右子作为根结点判断，直至结束。到达每一个结点时，打印该结点数据，即得先序遍历结果。 2.中序遍历：中序遍历是首先判断该结点是否为空，为空则结束，不为空则将左子作为根结点再进行判断，打印左子，然后打印二叉树的根结点，最后再将右子作为参数进行判断，打印右子，直至结束。 3.后续遍历：指针到达一个结点时，判断该结点是否为空，为空则停止遍历，不为空则将左子作为新的结点参数进行判断，打印左子。左子判断完成后，将右子作为结点参数传入判断，打印右子。左右子判断完成后打印根结点。 非递归算法： 1.先序遍历：首先建立一个栈，当指针到达根结点时，打印根结点，判断根结点是否有左子和右子。有左子和右子的话就打印左子同时将右子入栈，将左子作为新的根结点进行判断，方法同上。若当前结点没有左子，则直接将右子打印，同时将右子作为新的根结点判断。若当前结点没有右子，则打印左子，同时将左子作为新的根结点判断。若当前结点既没有左子也没有右子，则当前结点为叶子结点，此时将从栈中出栈一个元素，作为当前的根结点，打印结点元素，同时将当前结点同样按上述方法判断，依次进行。直至当前结点的左右子都为空，且栈为空时，遍历结束。 2.中序遍历：首先建立一个栈，定义一个常量flag（flag为0或者1），用flag记录结点的左子是否去过，没有去过为0，去过为1，默认为0.首先将指针指向根结点，将根结点入栈，然后将指针指向左子，左子作为新的结点，将新结点入栈，然后再将指针指向当前结点的左子，直至左子为空，则指针返回，flag置1，出栈一个元素，作为当前结点，打印该结点，然后判断flag，flag为1则将指针指向当前结点右子，将右子作为新的结点，结点入栈，再次进行上面的判断，直至当前结点右子也为空，则再出栈一个元素作为当前结点，一直到结束，使得当前结点右子为空，且栈空，遍历结束。 3.后续遍历：首先建立两个栈，然后定义两个常量。第一个为status，取值为0，1，2.0代表左右子都没有去过，1代表去过左子，2，代表左右子都去过，默认为0。第二个常量为flag，取值为0或者1，0代表进左栈，1代表进右栈。初始时指针指向根结点，判断根结点是否有左子，有左子则，将根结点入左栈，status置0，flag置0，若没有左子则判断结点有没有右子，有右子就把结点入右栈，status置0，flag置1，若左右子都没有，则打印该结点，并将指针指向空，此时判断flag，若flag为0，则从左栈出栈一个元素作为当前结点，重新判断；若flag为1则从右栈出栈一个元素作为当前结点，重新判断左右子是否去过，若status 为1，则判断该结点有没有右子，若有右子，则将该结点入右栈，status置1，flag置1，若没有右子，则打印当前结点，并将指针置空，然后再次判断flag。若当前结点status为2，且栈为空，则遍历结束。若指针指向了左子，则将左子作为当前结点，判断其左右子情况，按上述方法处理，直至遍历结束。
二叉树的建立及几种简单的遍历方法
#include "stdio.h" #include "stdlib.h" #define STACK_INIT_SIZE 100 //栈存储空间初始分配量 #define STACKINCREMENT 10 //存储空间分配增量 //------二叉树的存储结构表示------// typedef struct BiTNode{ int data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; //-----顺序栈的存储结构表示------// typedef struct{ BiTree *top; BiTree *base; int stacksize; }SqStack; //*************************************************** //构造一个空栈s SqStack *InitStack(); //创建一颗二叉树 BiTree CreatBiTree(); //判断栈空 int StackEmpty(SqStack *S); //插入元素e为新的栈顶元素 void Push(SqStack *S,BiTree p); //若栈不为空，则删除s栈顶的元素e，将e插入到链表L中void Pop(SqStack *S,BiTree *q); //非递归先序遍历二叉树 void PreOrderTraverse(BiTree L); //非递归中序遍历二叉树 void InOrderTraverse(BiTree L); //非递归后序遍历二叉树 void PostOrderTraverse(BiTree L); //递归后序遍历二叉树 void PostOrder(BiTree bt); //递归中序遍历二叉树 void InOrder(BiTree bt); //递归先序遍历二叉树 void PreOrder(BiTree bt); //***************************************************
二叉树三种遍历算法代码_
二叉树三种遍历算法的源码 二叉树三种遍历算法的源码背诵版 本文给出二叉树先序、中序、后序三种遍历的非递归算法，此三个算法可视为标准算法，直接用于考研答题。 1.先序遍历非递归算法 #define maxsize 100 typedef struct { Bitree Elem[maxsize]; int top; }SqStack; void PreOrderUnrec(Bitree t) { SqStack s; StackInit(s); p=t; while (p!=null || !StackEmpty(s)) { while (p!=null) //遍历左子树 { visite(p->data); push(s,p); p=p->lchild; }//endwhile if (!StackEmpty(s)) //通过下一次循环中的内嵌while实现右子树遍历 { p=pop(s); p=p->rchild; }//endif }//endwhile }//PreOrderUnrec 2.中序遍历非递归算法 #define maxsize 100 typedef struct { Bitree Elem[maxsize];
int top; }SqStack; void InOrderUnrec(Bitree t) { SqStack s; StackInit(s); p=t; while (p!=null || !StackEmpty(s)) { while (p!=null) //遍历左子树 { push(s,p); p=p->lchild; }//endwhile if (!StackEmpty(s)) { p=pop(s); visite(p->data); //访问根结点 p=p->rchild; //通过下一次循环实现右子树遍历}//endif }//endwhile }//InOrderUnrec 3.后序遍历非递归算法 #define maxsize 100 typedef enum{L,R} tagtype; typedef struct { Bitree ptr; tagtype tag; }stacknode; typedef struct { stacknode Elem[maxsize]; int top; }SqStack; void PostOrderUnrec(Bitree t)
二叉树遍历课程设计心得【模版】
目录 一．选题背景 (1) 二．问题描述 (1) 三．概要设计 (2) 3.1.创建二叉树 (2) 3.2.二叉树的非递归前序遍历示意图 (2) 3.3.二叉树的非递归中序遍历示意图 (2) 3.4.二叉树的后序非递归遍历示意图 (3) 四．详细设计 (3) 4.1创建二叉树 (3) 4.2二叉树的非递归前序遍历算法 (3) 4.3二叉树的非递归中序遍历算法 (4) 4.4二叉树的非递归后序遍历算法 (5) 五．测试数据与分析 (6) 六．源代码 (6) 总结 (10) 参考文献: (11)
一．选题背景 二叉树的链式存储结构是用指针建立二叉树中结点之间的关系。二叉链存储结构的每个结点包含三个域，分别是数据域，左孩子指针域，右孩子指针域。因此每个结点为 由二叉树的定义知可把其遍历设计成递归算法。共有前序遍历、中序遍历、后序遍历。可先用这三种遍历输出二叉树的结点。 然而所有递归算法都可以借助堆栈转换成为非递归算法。以前序遍历为例，它要求首先要访问根节点，然后前序遍历左子树和前序遍历右子树。特点在于所有未被访问的节点中，最后访问结点的左子树的根结点将最先被访问，这与堆栈的特点相吻合。因此可借助堆栈实现二叉树的非递归遍历。将输出结果与递归结果比较来检验正确性。。 二．问题描述 对任意给定的二叉树（顶点数自定）建立它的二叉链表存贮结构，并利用栈的五种基本运算（置空栈、进栈、出栈、取栈顶元素、判栈空）实现二叉树的先序、中序、后序三种遍历，输出三种遍历的结果。画出搜索顺序示意图。
三．概要设计 3.1.创建二叉树 3.2.二叉树的非递归前序遍历示意图 图3.2二叉树前序遍历示意图3.3.二叉树的非递归中序遍历示意图 图3.3二叉树中序遍历示意图
二叉树习题及答案
1.设一棵完全二叉树共有699 个结点，则在该二叉树中的叶子结点数？ 1根据二叉树的第i层至多有2A(i - 1)个结点；深度为k的二叉树至多有2A k - 1 个结点(根结点的深度为1)”这个性质： 因为2A9-1 < 699 < 2A10-1 , 所以这个完全二叉树的深度是10，前9 层是一个满二叉树， 这样的话，前九层的结点就有2A9-1=511 个；而第九层的结点数是2A(9-1)=256 所以第十层的叶子结点数是699-511=188 个；现在来算第九层的叶子结点个数。由于第十层的叶子结点是从第九层延伸的，所以应该去掉第九层中还有子树的结点。因为第十层有188 个，所以应该去掉第九层中的188/2=94 个；所以，第九层的叶子结点个数是256-94=162，加上第十层有188 个，最后结果是350 个 2完全二叉树：若二叉树中最多只有最下面两层的结点的度可以小于2，并且最下面一层的结点 (叶结点) 都依次排列在该层最左边的位置上，这样的二叉树为完全二叉树。 比如图：完全二叉树除叶结点层外的所有结点数(叶结点层以上所有结点数)为奇数，此题中，699 是奇数，叶结点层以上的所有结点数为保证是奇数，则叶结点数必是偶数，这样我们可以立即选出答案为B！如果完全二叉树的叶结点都排满了，则是满二叉树，易得满二叉树的叶结点数是其以上所有层结点数+1 比如图： 此题的其实是一棵满二叉树，我们根据以上性质，699+1=700，700/2=350，即叶结点数为350，叶结点层以上所有结点数为350-1=349。 3完全二叉树中，只存在度为2 的结点和度为0 的结点，而二叉树的性质中有一条是： nO=n2+1 ; nO指度为0的结点，即叶子结点，n2指度为2的结点，所以2n2+1=699 n2=349 ; n0=350 2.在一棵二叉树上第 5 层的结点数最多是多少一棵二叉树，如果每个结点都是是满的，那么会满足2A(k-1)1 。所以第5 层至多有2A(5-1)=16 个结点！ 3.在深度为5 的满二叉树中，叶子结点的个数为答案是16 ~ 叶子结点就是没有后件的结点~ 说白了~ 就是二叉树的最后一层~ 深度为K 的二叉树~ 最多有2Ak-1 个结点~ 最多有2A(k-1) 个结点~ 所以此题~ 最多有2A5-1=31 个结点~ 最多有2A(5-1)=16 个叶子结点~ 4.某二叉树中度为2 的结点有18 个，则该二叉树中有几个叶子结点？结点的度是指树中每个结点具有的子树个数或者说是后继结点数。 题中的度为2 是说具有的2 个子树的结点；二叉树有个性质：二叉树上叶子结点数等于度为2 的结点数加1。 5.在深度为7 的满二叉树中，度为2 的结点个数为多少，就是第一层只有一个节点，他有两个子节点，第二层有两个节点，他们也都有两个子节点以此类推，所以到第6 层，就有2的5次方个节点，他们都有两个子节点最后第7 层都没有子节点了。因为是深度为7 的。 所以就是1+2+4+8+16+32 了 2深度为1的时候有0个 深度为2的时候有1个 深度为3的时候有3个 深度为4的时候有7个 深度为n的时候有（2的n-1次方减1 ）个 6?—棵二叉树中共有70个叶子结点与80个度为1的结点，则该二叉树中的总结点数为？
二叉树的层次遍历算法
二叉树层次遍历算法实现 问题描述 对任意输入的表示某二叉树的字符序列，完成二叉树的层次遍历算法，并输出其遍历结果。 注：所需Queue ADT的实现见附录。 输入描述 从键盘上输入一串字符串，该字符串为二叉树的先序遍历结果，其中如果遍历到空树时用字符”#”代替。 输出描述 从显示器上输出二叉树的按层次遍历结果。 输入与输出示例 输入： +A##/*B##C##D## 输出： +A/*DBC 输入： ABD##GJ###CFH##I### 输出： ABCDGFJHI 附录(仅供参考)： #include
//注：需要定义ElementType类型，如果是二叉树， // 则应定义为指向二叉树中结点的指针类型 //格式如: // typedef Tree ElementType; // 队列存储结构采用循环队列 struct QueueRecord; typedef struct QueueRecord *Queue; int IsEmpty(Queue Q); int IsFull(Queue Q); Queue CreateQueue(int MaxElements); void DisposeQueue(Queue Q); void MakeEmpty(Queue Q); int Enqueue(ElementType X, Queue Q); ElementType Front(Queue Q); int Dequeue(Queue Q, ElementType &X); #define MinQueueSize ( 5 ) struct QueueRecord { int Capacity; int Front; int Rear; ElementType *Array; }; int IsEmpty(Queue Q) { return ((Q->Rear + 1)% Q->Capacity == Q->Front); } int IsFull(Queue Q) { return ((Q->Rear + 2) % Q->Capacity == Q->Front); } Queue CreateQueue(int MaxElements) { Queue Q; if (MaxElements < MinQueueSize) return NULL; Q = (Queue)malloc(sizeof(struct QueueRecord));
二叉树遍历算法的实现
二叉树遍历算法的实现 题目：编制二叉树遍历算法的实现的程序 一．需求分析 1.本演示程序中，二叉树的数据元素定义为非负的整型（unsigned int）数据，输 入-1表示该处没有节点 2.本演示程序输入二叉树数据均是按先序顺序依次输入 3.演示程序以用户和计算机对话方式执行，即在计算机终端上显示“提示信息” 之后，由用户在键盘上输入演示程序中规定的运算命令；相应的输入数据和运 算结果显示在其后 4.本实验一共包括三个主要程序，分别是：1）二叉树前序，中序，后序遍历递归 算法实现2）二叉树前序中序遍历非递归算法实现3)二叉树层次遍历算法实现 5.本程序执行命令包括：1）构建二叉树2）二叉树前序递归遍历3）二叉树中序 递归遍历4）二叉树后序递归遍历5）二叉树前序非递归遍历6）二叉树中序非 递归遍历7）二叉树层次遍历 6.测试数据 （1）7 8 -1 9 10 -1 -1 -1 6 11 -1 -1 12 13 -1 -1 14 -1 -1 （2）1 -1 -1 （3）7 8 -1 -1 9 -1 -1 二．概要设计 1.为实现二叉树的遍历算法，我们首先给出如下抽象数据类型 1）二叉树的抽象数据类型 ADT BiTree{ 数据对象D:D是具有相同特性的数据元素的集合 数据关系R： 若D=Φ，则R=Φ，称BiTree是空二叉树； 若D≠Φ，则R={H}，H是如下二元关系： (1)在D中存在唯一的成为根的数据元素root，它在关系H下无前驱； (2)若D-{H}≠Φ，则存在D-{root}={D1,D r}，且D1∩D r=Φ (3)若D1≠Φ，则D1中存在唯一的元素x1，
求二叉树中节点的最大距离
求二叉树中节点的最大距离
如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，我们姑且定义“距 离”为两个节点之间边的个数。 写一个程序求一棵二叉树中相距最远的两个节点之间的距离。 如图 3-11 所示，粗箭头的边表示最长距离：
图 3-11
树中相距最远的两个节点 A，B
分析与解法
我们先画几个不同形状的二叉树，（如图 3-12 所示），看看能否得到一些启示。
图 3-12
几个例子?
从例子中可以看出，相距最远的两个节点，一定是两个叶子节点，或者是一个叶子节点 到它的根节点。（为什么？） 【解法一】 根据相距最远的两个节点一定是叶子节点这个规律，我们可以进一步讨论。 对于任意一个节点，以该节点为根，假设这个根有 K 个孩子节点，那么相距最远的两 个节点 U 和 V 之间的路径与这个根节点的关系有两种情况： 1. 若路径经过根Root，则U和V是属于不同子树的，且它们都是该子树中到根节点最远 的节点，否则跟它们的距离最远相矛盾。这种情况如图3-13所示：
图 3-13
相距最远的节点在左右最长的子树中
2. 如果路径不经过Root，那么它们一定属于根的K个子树之一。并且它们也是该子树中 相距最远的两个顶点。如图3-14中的节点A：
图 3-14
相距最远的节点在某个子树下
因此，问题就可以转化为在子树上的解，从而能够利用动态规划来解决。 设第 K 棵子树中相距最远的两个节点：Uk 和 Vk，其距离定义为 d（Uk, Vk），那么节点 Uk 或 Vk 即为子树 K 到根节点 Rk 距离最长的节点。不失一般性，我们设 Uk 为子树 K 中到根 节点 Rk 距离最长的节点，其到根节点的距离定义为 d（Uk, R）。取 d（Ui, R）（1≤i≤k）中 最大的两个值 max1 和 max2，那么经过根节点 R 的最长路径为 max1+max2+2，所以树 R 中 相距最远的两个点的距离为：max{d（U1, V1）, …, d（Uk, Vk），max1+max2+2}。 采用深度优先搜索如图 3-15，只需要遍历所有的节点一次，时间复杂度为 O（|E|）= O （|V|-1），其中 V 为点的集合，E 为边的集合。
图 3-15
深度遍历示意图?
示例代码如下，我们使用二叉树来实现该算法。 代码清单 3-11
// 数据结构定义
实验 二叉树遍历算法及应用
实验二叉树遍历算法及应用 实验报告二叉树的遍历应用算法测试实验日期:______________ 学生姓 名:______________ 班级:_______________ 一、实习目的: 1、深入了解二叉树的存储结构及二叉树的遍历方法; 2、掌握二叉树的遍历算法及应用。 二、实习内容及要求 ----------------------------------------------------------------------------------------------------------------------------------------- 应用遍历思想，建立一棵如下图所示的二叉树，并能够完成如下操作: 1. 输出该二叉树的先序、中序、后序遍历序列; 2. 拷贝该树，生成一棵新树; 3. 将原树拆分成左右2棵树，并分别输出该二叉树左子树的遍历序列和右子树的遍历序列; 4. 利用遍历算法输出复制生成的树中结点总数、叶子总数、二叉树高度，并能够输出此二叉树中的叶子 结点。 ----------------------------------------------------------------------------------------------------------------------------------------- 附加:应用二叉树的顺序存储结构，实现建树。 并设计一个算法，实现能够输入一棵树中的双亲结点，输出该双亲结点的所有孩子结点的算法。
三、数据结构设计 (请将数据结构设计填写在此部分。) 四、测试 分别给出以下三棵树的测试结果