二叉树的遍历程序（急急急！求C语言的数据结构二叉树递归遍历程序！）

本文目录

• 急急急！求C语言的数据结构二叉树递归遍历程序！
• 二叉树的遍历过程是怎样的
• C语言二叉树遍历程序
• 谁能提供一个二叉树先序遍历的程序
• 求一个二叉树遍历的程序
• 如何编写一个二叉树的遍历

急急急！求C语言的数据结构二叉树递归遍历程序！

#include"stdio.h"局启//二轿腊慧叉树
#include"stdlib.h"
typedef
struct
node
{
char
data;
struct
node
*lchild,*rchild;
}BinTNode;
typedef
BinTNode*
BinTree;
void
GreateBinTree(BinTree
*T)//以先序遍历为依据构造二叉树,T为指向根指针的指针.
{
//空结闭答点以空格代替.
char
ch;
if((ch=getchar())==’
’)
*T=NULL;
else
{
*T=(BinTree)malloc(sizeof(BinTNode));
(*T)-》data=ch;
GreateBinTree(&((*T)-》lchild));
GreateBinTree(&((*T)-》rchild));
}
}
void
Lorder(BinTree
T)//先序遍历二叉树.
{
if(T)
{
printf("%c
",T-》data);
Lorder(T-》lchild);
Lorder(T-》rchild);
}
}
void
Morder(BinTree
T)//中序遍历二叉树.
{
if(T)
{
Morder(T-》lchild);
printf("%c
",T-》data);
Morder(T-》rchild);
}
}
void
Rorder(BinTree
T)//后序遍历二叉树.
{
if(T)
{
Rorder(T-》lchild);
Rorder(T-》rchild);
printf("%c
",T-》data);
}
}

二叉树的遍历过程是怎样的

楼主你好，因技术有限，所以在网上找了一些相关的资料，希望可以帮助到你。树是一种简单的非线性结构，所有元素耐亏之间具有明显的层次特性。
在树结构中，每一个结点只有一个前件，称为父结点，没有前件的结点只有一个，称为树的根结点，简称树的根。每一个结点可以有多个后件，称为该结点的子结点。没有后件的结点称为叶子结点。
在树结构中，一个结点所拥有的后件的个数称为该结点的度，所有结点中最大的度称为树的轮枝度。树的最大层次称为树的深度。
二*树的特点：（1）非空二*树只有一个根结点；（2）每一个结点最多有两棵子树，且分别称为该结点的左子树与右子树。
二*树的基本性质：
（1）在二*树的第k层上，最多有2k-1(k≥1)个结点；
（2）深度为m的二*树最多有2m-1个结点；
（3）度为0的结点（即叶子结点）总是比度为2的结点多一个；
（4）具有n个结点的二*树，其深度至少为表示取log2n的整数部分；
（5）具有n个结点的完全二*树的深度为+1；
（6）设完全二*树共有n个结点。如果从根结点开始，按层序（每一层从左到右）用自然数1，2，….n给结点进行编号（k=1,2….n），有以下结论：
①若k=1，则该结点为根结点，它没有父结点；若k》1，则该结点的父结点编号为INT(k/2)；
②若2k≤n，则编号为k的结点的左子结点编号为2k；否则该结点无左子结点（也无右子结点）；
③若2k+1≤n，则编号为k的结点的右子结点编号为2k+1；否则该结点无右子结点。
满二*树是指除最后一层外，每一层上的所有结点有两个子结点，则k层上有2k-1个结点深度为m的满二*树有2m-1个结点。
完全二*树是指除最后一层外，每一层上的结点数昌桐神均达到最大值，在最后一层上只缺少右边的若干结点。
二*树存储结构采用链式存储结构，对于满二*树与完全二*树可以按层序进行顺序存储。
二*树的遍历：
（1）前序遍历（DLR），首先访问根结点，然后遍历左子树，最后遍历右子树；
（2）中序遍历（LDR），首先遍历左子树，然后访问根结点，最后遍历右子树；
（3）后序遍历（LRD）首先遍历左子树，然后访问遍历右子树，最后访问根结点。
***隐藏网址***

C语言二叉树遍历程序

先看下creat这个函数:
status creat(bitnode *t)/*先序建立二叉树*/
{
char ch;
ch=getch();putch(ch);
if(ch==’0’) t=NULL;
else
{
t=(bitnode *)malloc(sizeof(bitnode));
if(!t)
exit(OVERFLOW);
t-》data=ch;
creat(t-》lchild);
creat(t-》rchild);
}
return OK;
}
其中有句代码是t=(bitnode *)malloc(sizeof(bitnode));
这是给t赋值，由于t是参数，这样做是不能返回的。
我知道你的意思是想通过指针返回，但是那样的用法应该是对t所指向的变量赋值，也就是对*t赋值。
如果你还没理解的话看下函数里的递归调用：creat(t-》lchild);调用函数后，本意是要给t-》lchild赋值的，但是是做不到的，因为要改变一个变量的值的话，应该传的是它的地址。
可能你觉得有点乱了，我举个函数中用指针做参数来返回的例子：
假如要用指针返回一个整型的变量，那么指针应该是指向整型变量的，即int*
这里应该是要返回一个struct bitnode *类型的，也就是返回的值就是个指针，那么参数就应知和该是一蚂锋个指向这种指针的指针，即struct bitnode **
可以这么修改：
status creat(bitnode **t) //多了个*
{
char ch;
ch=getch();putch(ch);
if(ch==’0’) *t=NULL; //多了个*
else
{
*t=(bitnode *)malloc(sizeof(bitnode)); //多了个*
if(!*t) //多了个*
exit(OVERFLOW);
(*t)-》data=ch;
creat(&(*t)-》lchild); //注意不同
creat(&(*t)-》rchild);
}
return OK;
}
主函数这么改
status main()
{
bitnode* t1; //多了个*
creat(&t1);
pre(t1,print); /闷猛晌/少了个&
getch();
return 0;
}
另外一个编译错误就是
int pre(bitnode *t,status (*visit)())
指针函数后面应该带参数，改为
int pre(bitnode *t,status (*visit)(bitnode *))

谁能提供一个二叉树先序遍历的程序

template《class
elemtype》//二叉树结点struct
nodetype{elemtype
info;//结点信息nodetype《elemtype》
*llink;//左子树nodetype《elemtype》
*rlink;//右子树};template《class
elemtype》void
inorder(nodetype《elemtype》
*p)//中序遍历{if(NULL!=p){inorder(p-》llink);//使用递归算法先遍历左唯清子树cout《《p-》info《《"
";//访问指银结点inorder(p-》rlink);//遍历右子树}}
我也正在唯山宴学数据结构，也不太会，编了个中序遍历的小程序，仅供参考

求一个二叉树遍历的程序

#include 《stdlib.h》
struct tree /* 树的结构宣告 */
{
int data; /* 节点数据 */
struct tree *left; /* 指向左子树的指标 */
struct tree *right; /* 指向右子树的指标 */
};
typedef struct tree treenode; /* 树竖汪的结构新型态 */
typedef treenode *btree; /* 宣告树节点指标型态 */
/* ---------------------------------------- */
/* 插入二叉树的节点 */
/* ---------------------------------------- */
btree insertnode(btree root,int value)
{
btree newnode; /* 树根指标 */
btree current; /* 目前树节点指标 */
btree back; /* 父节态纤裂点指标 */
/* 建立新节点记忆体 */
newnode = ( btree ) malloc(sizeof(treenode));
newnode-》data = value; /* 建立节点内容 */
newnode-》left = NULL; /* 设定指标初值 */
newnode-》right = NULL; /* 设定帆闭指标初值 */
if ( root == NULL ) /* 是否是根节点 */
{
return newnode; /* 传回新节点位置 */
}
else
{
current = root; /* 保留目前树指标 */
while ( current != NULL )
{
back = current; /* 保留父节点指标 */
if ( current-》data 》 value ) /* 比较节点值 */
current = current-》left; /* 左子树 */
else
current = current-》right; /* 右子树 */
}
if ( back-》data 》 value ) /* 接起父子的链结 */
back-》left = newnode; /* 左子树 */
else
back-》right = newnode; /* 右子树 */
}
return root; /* 传回树根指标 */
}
/* ---------------------------------------- */
/* 建立二叉树 */
/* ---------------------------------------- */
btree createbtree(int *data,int len)
{
btree root = NULL; /* 树根指标 */
int i;
for ( i = 0; i 《 len; i++ ) /* 用回路建立树状结构 */
root = insertnode(root,data);
return root;
}
/* ---------------------------------------- */
/* 二叉树中序遍历 */
/* ---------------------------------------- */
void inorder(btree ptr)
{
if ( ptr != NULL ) /* 终止条件 */
{
inorder(ptr-》left); /* 左子树 */
printf("\n",ptr-》data); /* 列印节点内容 */
inorder(ptr-》right); /* 右子树 */
}
}
/* ---------------------------------------- */
/* 主程式: 建立二叉树且用中序遍历列印出来. */
/* ---------------------------------------- */
void main()
{
btree root = NULL; /* 树根指标 */
/* 二叉树节点数据 */
int data = { 5, 6, 4, 8, 2, 3, 7, 1, 9 };
root = createbtree(data,9); /* 建立二叉树 */
printf("树的节点内容 \n");
inorder(root); /* 中序遍历二叉树 */
}
/* ======================================== */
/* 二叉树的前序遍历 */
/* ======================================== */
#include 《stdlib.h》
struct tree /* 树的结构宣告 */
{
int data; /* 节点数据 */
struct tree *left; /* 指向左子树的指标 */
struct tree *right; /* 指向右子树的指标 */
};
typedef struct tree treenode; /* 树的结构新型态 */
typedef treenode *btree; /* 宣告树节点指标型态 */
/* ---------------------------------------- */
/* 插入二叉树的节点 */
/* ---------------------------------------- */
btree insertnode(btree root,int value)
{
btree newnode; /* 树根指标 */
btree current; /* 目前树节点指标 */
btree back; /* 父节点指标 */
/* 建立新节点记忆体 */
newnode = ( btree ) malloc(sizeof(treenode));
newnode-》data = value; /* 建立节点内容 */
newnode-》left = NULL; /* 设定指标初值 */
newnode-》right = NULL; /* 设定指标初值 */
if ( root == NULL ) /* 是否是根节点 */
{
return newnode; /* 传回新节点位置 */
}
else
{
current = root; /* 保留目前树指标 */
while ( current != NULL )
{
back = current; /* 保留父节点指标 */
if ( current-》data 》 value ) /* 比较节点值 */
current = current-》left; /* 左子树 */
else
current = current-》right; /* 右子树 */
}
if ( back-》data 》 value ) /* 接起父子的链结 */
back-》left = newnode; /* 左子树 */
else
back-》right = newnode; /* 右子树 */
}
return root; /* 传回树根指标 */
}
/* ---------------------------------------- */
/* 建立二叉树 */
/* ---------------------------------------- */
btree createbtree(int *data,int len)
{
btree root = NULL; /* 树根指标 */
int i;
for ( i = 0; i 《 len; i++ ) /* 用回路建立树状结构 */
root = insertnode(root,data);
return root;
}
/* ---------------------------------------- */
/* 二叉树前序遍历 */
/* ---------------------------------------- */
void preorder(btree ptr)
{
if ( ptr != NULL ) /* 终止条件 */
{
printf("\n",ptr-》data); /* 列印节点内容 */
preorder(ptr-》left); /* 左子树 */
preorder(ptr-》right); /* 右子树 */
}
}
/* ---------------------------------------- */
/* 主程式: 建立二叉树且用前序遍历列印出来. */
/* ---------------------------------------- */
void main()
{
btree root = NULL; /* 树根指标 */
/* 二叉树节点数据 */
int data = { 5, 6, 4, 8, 2, 3, 7, 1, 9 };
root = createbtree(data,9); /* 建立二叉树 */
printf("树的节点内容 \n");
preorder(root); /* 前序遍历二叉树 */
}
/* ======================================== */
/* 二叉树的后序遍历 */
/* ======================================== */
#include 《stdlib.h》
struct tree /* 树的结构宣告 */
{
int data; /* 节点数据 */
struct tree *left; /* 指向左子树的指标 */
struct tree *right; /* 指向右子树的指标 */
};
typedef struct tree treenode; /* 树的结构新型态 */
typedef treenode *btree; /* 宣告树节点指标型态 */
/* ---------------------------------------- */
/* 插入二叉树的节点 */
/* ---------------------------------------- */
btree insertnode(btree root,int value)
{
btree newnode; /* 树根指标 */
btree current; /* 目前树节点指标 */
btree back; /* 父节点指标 */
/* 建立新节点记忆体 */
newnode = ( btree ) malloc(sizeof(treenode));
newnode-》data = value; /* 建立节点内容 */
newnode-》left = NULL; /* 设定指标初值 */
newnode-》right = NULL; /* 设定指标初值 */
if ( root == NULL ) /* 是否是根节点 */
{
return newnode; /* 传回新节点位置 */
}
else
{
current = root; /* 保留目前树指标 */
while ( current != NULL )
{
back = current; /* 保留父节点指标 */
if ( current-》data 》 value ) /* 比较节点值 */
current = current-》left; /* 左子树 */
else
current = current-》right; /* 右子树 */
}
if ( back-》data 》 value ) /* 接起父子的链结 */
back-》left = newnode; /* 左子树 */
else
back-》right = newnode; /* 右子树 */
}
return root; /* 传回树根指标 */
}
/* ---------------------------------------- */
/* 建立二叉树 */
/* ---------------------------------------- */
btree createbtree(int *data,int len)
{
btree root = NULL; /* 树根指标 */
int i;
for ( i = 0; i 《 len; i++ ) /* 用回路建立树状结构 */
root = insertnode(root,data);
return root;
}
/* ---------------------------------------- */
/* 二叉树后序遍历 */
/* ---------------------------------------- */
void postorder(btree ptr)
{
if ( ptr != NULL ) /* 终止条件 */
{
postorder(ptr-》left); /* 左子树 */
postorder(ptr-》right); /* 右子树 */
printf("\n",ptr-》data); /* 列印节点内容 */
}
}
/* ---------------------------------------- */
/* 主程式: 建立二叉树且用后序遍历列印出来. */
/* ---------------------------------------- */
void main()
{
btree root = NULL; /* 树根指标 */
/* 二叉树节点数据 */
int data = { 5, 6, 4, 8, 2, 3, 7, 1, 9 };
root = createbtree(data,9); /* 建立二叉树 */
printf("树的节点内容 \n");
postorder(root); /* 后序遍历二叉树 */
}

如何编写一个二叉树的遍历

#include《iostream.h》
#include《math.h》睁余
struct BiT {
char data;
BiT *lchild, *rchild;
};
BiT* CreateBiTree(int n) {
//构造二叉链表表示的二叉树T
int i, m = pow(2,n)-1;
BiT *c = new BiT;
for(i = 0; i 《 m; i++) {
c.data = ’A’ + i;
c;
c;
}
for(i = pow(2,n-1)-1; i 《 m; i++)
c.rchild = NULL;
return c;
}
void PreOrderTraverse(BiT *T) {
//悉绝滚 先序遍历二叉树T
if (T) {
cout《《T-》data;
PreOrderTraverse(T-》lchild);
PreOrderTraverse(T-》rchild);
}
}
void InOrderTraverse(BiT *T) {
// 中序遍历二叉树T
if (T) {
InOrderTraverse(T-》lchild);
cout《《T-》data;
InOrderTraverse(T-》rchild);
}
}
void PostOrderTraverse(BiT *T) {
// 后序遍历二叉树T
if (T) {
PostOrderTraverse(T-》lchild);
PostOrderTraverse(T-》rchild);
cout《《T-》data;
}
}
struct Queue {
BiT *P;
Queue *next;
};
struct LinkQueue {
Queue *front; //队头指针
Queue *rear; //队尾指针
};
void InitQueue(LinkQueue *Q, BiT *T) {
Q-》front = new Queue;
Q-》front-》P = T;
Q-》rear = new Queue;
Q-》front-》next = Q-》rear;
Q-》rear-》P = NULL;
}
void EnQueue(LinkQueue *Q, BiT *e) {
if(!e) return;
Q-》rear-》P = e;
Q-》rear-》next = new Queue;
Q-》rear = Q-》rear-》next;
Q-》rear-》P = NULL;
}
void DeQueue(LinkQueue *Q) {
Queue *q = Q-》front;
Q-》front = Q-》front-》next;
delete q;
}
void LevelOrderTraverse(BiT *T) {
if(!T) return;
LinkQueue *Q = new LinkQueue;
InitQueue(Q,T);
while(Q-》front-》P) {
cout《《Q-》front-》P-》data;
EnQueue(Q,Q-》front-》P-》lchild);
EnQueue(Q,Q-》front-》宏孙P-》rchild);
DeQueue(Q);
}
}
void main() {
int n;
cout《《" n = ";
cin》》n;
BiT *T = CreateBiTree(n);
do { cout《《"\n 1:先序遍历:"
"\n 2:中序遍历:"
"\n 3:后序遍历:"
"\n 4:层序遍历:"
"\n 0:退出"
"\n 选择____";
cin》》n;
switch(n) {
case 1: cout《《"\n 先序遍历: "; PreOrderTraverse(T); cout《《endl; break;
case 2: cout《《"\n 中序遍历: "; InOrderTraverse(T); cout《《endl; break;
case 3: cout《《"\n 后序遍历: "; PostOrderTraverse(T); cout《《endl; break;
case 4: cout《《"\n 层序遍历: "; LevelOrderTraverse(T); cout《《endl; break;
}
}while(n);
}