二叉树遍历代码c语言,求c语言数据结构二叉树的建树，前序遍历，输出树的代码，能用采纳。

更新日期：2025-7-20
浏览次数：19
网站地址：
标签：bitnode 二叉树遍历

二叉树遍历代码c语言,求c语言数据结构二叉树的建树，前序遍历，输出树的代码，能用采纳。详细介绍

本文目录一览：急求C语言写二叉树的遍历

下面是一个用
递归方法
编的二叉树遍历程序，供lz参考。
#include

//头文件

#include

#include

typedef

struct

bitnode

{

char

data;

struct

bitnode

*lchild,*rchild;

}

bitnode,*bitree;//定义结点类型

bitree

createbitree()//创建树

{

char

p;bitree

t;

scanf("%c",&p);

if(p=='

')

t=null;

else

{

t=(bitnode

*)malloc(sizeof(bitnode));//为结点开辟空间

t->data=p;

t->lchild=createbitree();

t->rchild=createbitree();

}

return

(t);

}

void

preorder(bitree

t)//

先序

{

if(t!=null)

{

printf("%c",t->data);

preorder(t->lchild);

preorder(t->rchild);

}

}

void

inorder(bitree

t)//

中序

{

if(t!=null)

{

inorder(t->lchild);

printf("%c",t->data);

inorder(t->rchild);

}

}

void

postorder(bitree

t)//

后序

{

if(t!=null)

{

postorder(t->lchild);

postorder(t->rchild);

printf("%c",t->data);

}

}

void

main()//主函数

{

bitree

ta;

ta=createbitree();

printf("先序遍历:");

printf("\n");

preorder(ta);

printf("\n");

printf("中序遍历:");

printf("\n");

inorder(ta);

printf("\n");

printf("后序遍历:");

printf("\n");

postorder(ta);

}

c语言二叉树的遍历

//---------------------------------------------------------------------------
#include

using namespace std;

typedef struct node

{

struct node *L,*R;

string name;

}NODE;

//输入

void Input(NODE **T,int num)

{

string name;

int L,R;

*T = new NODE[num];

for (int i=0;i
<num;)
{

cout << "输入第"<
<i+1<<"个结点名称、左右子序号:"<<endl;
cin >> name >> L >> R;

if(L >=num || R >=num)

{

cout << "输入结点序号非法，请重新输入"<
<endl;
continue;

}

(*T+i)->name = name;

(*T+i)->L = L==-1? NULL:*T+L;

(*T+i)->R = R==-1? NULL:*T+R;

i++;

}

}

//前序

void NLR(NODE *T)

{

if(T==NULL)return ;

cout <

name<<" ";

NLR(T->L);

NLR(T->R);

}

//中序

void LNR(NODE *T)

{

if(T==NULL)return ;

NLR(T->L);

cout <

name<<" ";

NLR(T->R);

}

//后序

void LRN(NODE *T)

{

if(T==NULL)return ;

NLR(T->L);

NLR(T->R);

cout <

name<<" ";

}

int main()

{

NODE *T=NULL,t;

int num;

cout << "输入结点数:"<
<endl;
cin >> num;

Input(&T,num);

cout <<"前序：";

NLR(T);

cout << endl;

cout <<"中序：";

LNR(T);

cout << endl;

cout <<"后序：";

LRN(T);

cout << endl;

system("PAUSE");

return 0;

}
</endl;

</endl;
</i+1<<"个结点名称、左右子序号:"<<endl;
</num;)

一道数据结构关于二叉树的问题，求写出C语言代码

二叉树是采用递归定义的，实现起来代码简洁（也许并不简单）。并且它在具体的计算机科学中有很重要的运用，是一种很重要的数据结构，二叉树有三种遍历和建立的方式。今天先学习一下它的建立和打印。
以下代码在Win-Tc1.9.1下编译通过。
#include

#define ElemType char

//节点声明，数据域、左孩子指针、右孩子指针

typedef struct BiTNode{

char data;

struct BiTNode *lchild,*rchild;

}BiTNode,*BiTree;

//先序建立二叉树

BiTree CreateBiTree(){

char ch;

BiTree T;

scanf("%c",&ch);

if(ch=='#')T=NULL;

else{

T = (BiTree)malloc(sizeof(BiTNode));

T->data = ch;

T->lchild = CreateBiTree();

T->rchild = CreateBiTree();

}

return T;//返回根节点

}

//先序遍历二叉树

void PreOrderTraverse(BiTree T){

if(T){

printf("%c",T->data);

PreOrderTraverse(T->lchild);

PreOrderTraverse(T->rchild);

}

}

//中序遍历

void InOrderTraverse(BiTree T){

if(T){

PreOrderTraverse(T->lchild);

printf("%c",T->data);

PreOrderTraverse(T->rchild);

}

}

//后序遍历

void PostOrderTraverse(BiTree T){

if(T){

PreOrderTraverse(T->lchild);

PreOrderTraverse(T->rchild);

printf("%c",T->data);

}

}

void main(){

BiTree T;

T = CreateBiTree();//建立

PreOrderTraverse(T);//输出

getch();

}

求二叉树遍历算法C语言实现的

Status
PreOrderTraverse
(
BiTree
T,
Status
(
*Visit
)
(
TElemType
e
)
)
{
//
采用二叉链表存储结构，Visit
是对数据元素操作的应用函数，先序遍历二叉树
T
的递归算法。
if
(
T
)
{
//
若
T
不为空
if
(
Visit
(
T->data
)
)
//
调用函数
Visit
if
(
PreOrderTraverse
(
T->lchild,
Visit
)
)
//
递归调用左子树
if
(
PreOrderTraverse
(
T->rchild,
Visit
)
)
return
OK;
//
递归调用右子树
return
ERROR;
}
else
return
OK;
}
//
PreOrderTraverse
下面是c语言的前序遍历二叉树的算法，在这里假设的节点元素值假设的为字符型，
说明：算法中用到了结构体，也用到了递归的方法，你看看怎么样，祝你好运！
#include"stdio.h"
typedef
char
ElemType;
typedef
struct
node
//定义链表结构
{
ElemType
data;
//定义节点值
struct
note
*lchild;
//定义左子节点值
struct
note
*rchild;
//定义右节点值
}BTree;
preorder(BTree
*root)
//前序遍历
{
if(roof!=NULL)
//如果不是空节点
{
printf("%c\n",root->data);
//输出当前节点
preorder(root->lchild);
//递归前序遍历左子节点
preorder(root->rchild);
//递归前序遍历右子节点
}
return;
//结束
}

阅读更多 >>> 什么是二叉树的先序扩展序列

求二叉树遍历算法C语言实现的

#include

typedef struct node{

int data;

struct node *lchild,*rchild;

}*treetp,tree;

treetp create (treetp t,int c);

void print1(treetp);

void print2(treetp);

void print3(treetp);

int number=0;

void main()

{

treetp t=0,r;

r=create (t,0);

printf("前序排列：");

print1 (r);

printf("\n中序排列：");

print2 (r);

printf("\n后序排列：");

print3 (r);

}

treetp create(treetp t,int c)

{

treetp p,di;

do{

scanf("%d",&c);

if (t==0)

{

t=(treetp)malloc(sizeof(tree));

t->lchild=t->rchild=0;

t->data=c;

}

else

{ p=t;

while(p!=0)

{

di=p;

if(c<(p->data))

p=p->lchild;

else

p=p->rchild;

}

if(c<(di->data))

{

treetp NEWdi=(treetp) malloc(sizeof(tree));

NEWdi->lchild=NEWdi->rchild=0;

NEWdi->data=c;

di->lchild=NEWdi;

}

else

{

treetp NEWdi=(treetp) malloc(sizeof(tree));

NEWdi->lchild=NEWdi->rchild=0;

NEWdi->data=c;

di->rchild=NEWdi;

}

}

++number;

}while(c!=0);

printf("叶子的数量：%d",number);

return t;

}

void print1(treetp t)

{

if (t!=0)

{

printf("%d ",t->data);

print1(t->lchild);

print1(t->rchild);

}

}

void print2(treetp t)

{

if (t!=0)

{

print2(t->lchild);

printf("%d ",t->data);

print2(t->rchild);

}

}

void print3(treetp t)

{

if (t!=0)

{

print3(t->lchild);

print3(t->rchild);

printf("%d ",t->data);

}

}

Status PreOrderTraverse ( BiTree T, Status ( *Visit ) ( TElemType e ) ) {

// 采用二叉链表存储结构，Visit 是对数据元素操作的应用函数，先序遍历二叉树 T 的递归算法。

if ( T ) { // 若 T 不为空

if ( Visit ( T->data ) ) // 调用函数 Visit

if ( PreOrderTraverse ( T->lchild, Visit ) ) // 递归调用左子树

if ( PreOrderTraverse ( T->rchild, Visit ) )

return OK; // 递归调用右子树

return ERROR;

}

else return OK;

} // PreOrderTraverse

求c语言数据结构二叉树的建树，前序遍历，输出树的代码，能用采纳。

/******************************************************/
/*
二叉树的建立深度优先遍历求叶子个数求深度
*/
/******************************************************/
#include
"stdio.h"
#include
"string.h"
#include
"stdlib.h"
#define
null
0
typedef
struct
bitnode{
int
data;
struct
bitnode
*lchild,*rchild;
}bitnode,*bitree;
/*创建一个二杈树以#号结束*/
bitree
create(bitree
t){
char
ch;
ch=getchar();
if(ch=='#')
t=null;
else{
t=(bitree)malloc(sizeof(bitnode));
t->data=ch;
t->lchild=create(t->lchild);
t->rchild=create(t->rchild);
}
return
t;
}
/*递归遍历*/
void
preorder(bitree
t){
if(t){
printf("%c",t->data);
/*先序*/
preorder(t->lchild);
/*printf("%c",t->data);
中序*/
preorder(t->rchild);
/*printf("%c",t->data);
后序*/
}
}
/*求深度*/
int
depth(bitree
t){
int
depthval,depl,depr;
if(!t)
depthval=0;
else{
depl=depth(t->lchild);
depr=depth(t->rchild);
depthval=1+(depl>depr?depl:depr);
}
return
depthval;
}
/*求叶子数*/
int
countleaf(bitree
t){
int
count=0;
if(!t)
count=0;
else
if((!t->lchild)&&(!t->rchild))
count++;
else
count=countleaf(t->lchild)+countleaf(t->rchild);
return
count;
}
/*主函数*/
main(){
bitree
t=null;
printf("\nplease
input
a
tree:");
t=create(t);
preorder(t);
printf("\ndepth:%d\nleave:%d\n",depth(t),countleaf(t));
system("pause");
}
程序以调试通过！！！！！
#include
#include
#define
MAXSIZE
100
//二叉树中最多的结点数　
typedef
char
TElemType;
typedef
struct
BiTNode
{
TElemType
data;
struct
BiTNode
*lchild,*rchild;
}BiTNode,*BiTree;
//定义函数指针
typedef
void(*
Visit)(BiTree);
//二叉树的初始化
void
Init_BiTree(BiTree
*T)
{
*T
=
NULL;
}
//判断二叉树是否为空,返回1
int
IsEmpty_BiTree(BiTree
*T)
{
return
*T
==
NULL;
}
//创建二叉树
void
Create_BiTree(BiTree
*T)
{
char
ch;
ch
=
getchar();
//当输入的是"#"时，认为该子树为空
if(ch
==
'#')
*T
=
NULL;
//创建树结点
else{
*T
=
(BiTree)malloc(sizeof(BiTNode));
(*T)->data
=
ch;
//生成树结点
//生成左子树
Create_BiTree(&(*T)->lchild);
//生成右子树
Create_BiTree(&(*T)->rchild);
}
}
//输出结点的值
void
Print_BiTreeNode(BiTree
T)
{
printf("%c\t",T->data);
}
//先序遍历二叉树
void
PreOrder_BiTree(BiTree
T,Visit
visit)
{
if(!IsEmpty_BiTree(&T))
{
visit(T);
PreOrder_BiTree(T->lchild,visit);
PreOrder_BiTree(T->rchild,visit);
}
}
int
main(){
BiTree
T;
//将二叉树初始为一个空的二叉树
Init_BiTree(&T);
//创建二叉树
Create_BiTree(&T);
//先序遍历
printf("\n先序遍历结果：");
PreOrder_BiTree(T,Print_BiTreeNode);
return
0;
}

阅读更多 >>> 递归算法和非递归算法的区别,递归算法与非递归算法

C语言二叉树的创建和遍历

void creat(tree *t1)
{
char ch;
struct node *th; //看到这个th了吗？不需要的
ch=getchar();
if(ch=='.') t1=NULL;
else
{
th=(tree *)malloc(sizeof(tree)); //改成t1=(tree *)malloc(sizeof(tree));
t1->c=ch;
printf("%c",t1->c);
creat(t1->lchild);
creat(t1->rchild);
}
我写了一个二叉树你给看看一定能行的我自己用了
#include "stdio.h"
#include "malloc.h"
#include "string.h"
#include "stdlib.h"
#define Max 20 //结点的最大个数
typedef struct BinTNode{
char data;
struct BinTNode *lchild,*rchild;
}BinTNode,*BinTree; //自定义二叉树的结点类型
//定义二叉树的指针
int NodeNum,leaf; //NodeNum为结点数，leaf为叶子数
//==========以广义表显示二叉树==============
void DisTree(BinTree T)
{
if(T)
{
printf("%c",T->data);
if((T->lchild)||(T->rchild))
{
if(T->lchild)
{
printf("%c",'(');
DisTree(T->lchild);
}
if(T->rchild)
{
printf("%c",',');
DisTree(T->rchild);
printf("%c",')');
}
}
}
}
//==========基于先序遍历算法创建二叉树==============
//=====要求输入先序序列，其中加入虚结点"#"以示空指针的位置==========
BinTree CreatBinTree(BinTree T)
{
char ch;
ch=getchar();
if(ch=='#')
T=NULL;
else
{
if(!(T=(BinTNode *)malloc(sizeof(BinTNode))))
printf("Error!");
T->data=ch;
T->lchild=CreatBinTree(T->lchild);
T->rchild=CreatBinTree(T->rchild);
}
return T;
}
//========NLR 先序遍历=============
void Preorder(BinTree T)
{
if(T)
{
printf("%c",T->data);
Preorder(T->lchild);
Preorder(T->rchild);
}
}
//========LNR 中序遍历===============
void Inorder(BinTree T)
{
if(T){
Inorder(T->lchild);
printf("%c",T->data);
Inorder(T->rchild);
}
}
//==========LRN 后序遍历============
void Postorder(BinTree T)
{
if(T){
Postorder(T->lchild);
Postorder(T->rchild);
printf("%c",T->data);
}
}
//=====采用后序遍历求二叉树的深度、结点数及叶子数的递归算法========
int TreeDepth(BinTree T)
{
int hl,hr,max;
if(T){
hl=TreeDepth(T->lchild); //求左深度
hr=TreeDepth(T->rchild); //求右深度
max=hl>hr? hl:hr; //取左右深度的最大值
NodeNum=NodeNum+1; //求结点数
if(hl==0&&hr==0)
leaf=leaf+1; //若左右深度为0，即为叶子。
return(max+1);
}
else return(0);
}
//====利用"先进先出"（FIFO）队列，按层次遍历二叉树==========
void Levelorder(BinTree T)
{
int front=0,rear=1;
BinTNode *cq[Max],*p; //定义结点的指针数组cq
cq[1]=T; //根入队
while(front!=rear)
{
front=(front+1)%NodeNum;
p=cq[front]; //出队
printf("%c",p->data); //出队，输出结点的值
if(p->lchild!=NULL){
rear=(rear+1)%NodeNum;
cq[rear]=p->lchild; //左子树入队
}
if(p->rchild!=NULL){
rear=(rear+1)%NodeNum;
cq[rear]=p->rchild; //右子树入队
}
}
}
//==========主函数=================
void main()
{
BinTree T,root;
int i,depth;
printf("\n");
printf("输入完全二叉树的先序序列:"); //输入完全二叉树的先序序列，
// 用#代表虚结点，如ABD###CE##F##
root=CreatBinTree(T); //创建二叉树，返回根结点
DisTree(root);
printf("\n");
do //从菜单中选择遍历方式，输入序号。
{
printf("\t********** 菜单 ************\n");
printf("\n");
printf("\t1: 先序遍历\n");
printf("\t2: 中序遍历\n");
printf("\t3: 后序遍历\n");
printf("\t4: 该树的深度,结点数,叶子数\n");
printf("\t5: 层次遍历\n"); //按层次遍历之前，先选择4，求出该树的结点数。
printf("\t0: 退出\n");
printf("\t*******************************\n");
scanf("%d",&i);
//输入菜单序号（0-5）
switch(i)
{
case 1: {printf("Print Bin_tree Preorder: ");
Preorder(root); //先序遍历
}break;
case 2: {printf("Print Bin_Tree Inorder: ");
Inorder(root); //中序遍历
}break;
case 3: {printf("Print Bin_Tree Postorder: ");
Postorder(root); //后序遍历
}break;
case 4: {depth=TreeDepth(root); //求树的深度及叶子数
printf("树深=%d 树总结点数=%d",depth,NodeNum);
printf(" 树叶子数=%d",leaf);
}break;
case 5: {printf("LevePrint Bin_Tree: ");
Levelorder(root); //按层次遍历
}break;
default: exit(1);
}
}while(i>=0&&i<6);
}
兄弟你看看不懂再往下留言记得给我的劳动成果一点点奖励哦！！

求编一个c代码，输入满二叉树的先序遍历，输出中序遍历和后序遍历

lhj
在淘宝搜快客利，认准店主sinohzxu，官方自助话费充值
#include

#include

#define NULL 0

typedef struct btree

{

char data;

struct btree *pLeft;

struct btree *pRight;

}quickli;

quickli* constuctTree(char input[], int beginIndex, int endIndex)

{

if (beginIndex > endIndex) return NULL;

quickli* root=(quickli *)malloc(sizeof(quickli));

root->data=input[beginIndex];

root->pLeft=constuctTree(input , beginIndex+1,(endIndex+beginIndex)/2);

root->pRight=constuctTree(input , (endIndex+beginIndex)/2+1,endIndex);

return root;

}

void inorderTree(quickli* tree)

{

if (tree == NULL) return ;

inorderTree(tree->pLeft);

printf("%c",tree->data);

inorderTree(tree->pRight);

}

void postorderTree(quickli* tree)

{

if (tree == NULL) return ;

postorderTree(tree->pLeft);

postorderTree(tree->pRight);

printf("%c",tree->data);

}

int main()

{

printf("请输入一个满二叉树先序遍历（如ABCDEFG）：\n");

char input[100];

scanf("%s",input);

double check = log(strlen(input)+1)/log(2);

if(check != (int)check)

{

printf("错误：满二叉树的序列长度必须等于2^n-1（^是幂的意思）\n");

return -1;

}

quickli* tree=constuctTree(input,0,strlen(input)-1);

printf("中序遍历如下：\n");

inorderTree(tree);

printf("\n");

printf("后序遍历如下：\n");

postorderTree(tree);

printf("\n");

return 0;

}

在淘宝搜快客利，认准店主sinohzxu，官方自助话费充值

阅读更多 >>> js数组遍历方法,如何操作JS遍历多维数组

急急急！求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);
}
}
/******************************************************/
/*
二叉树的建立深度优先遍历求叶子个数求深度
*/
/******************************************************/
#include
"stdio.h"
#include
"string.h"
#include
"stdlib.h"
#define
NULL
0
typedef
struct
bitnode{
int
data;
struct
bitnode
*lchild,*rchild;
}bitnode,*bitree;
/*创建一个二杈树以#号结束*/
bitree
create(bitree
t){
char
ch;
ch=getchar();
if(ch=='#')
t=NULL;
else{
t=(bitree)malloc(sizeof(bitnode));
t->data=ch;
t->lchild=create(t->lchild);
t->rchild=create(t->rchild);
}
return
t;
}
/*递归遍历*/
void
preorder(bitree
t){
if(t){
printf("%c",t->data);
/*先序*/
preorder(t->lchild);
/*printf("%c",t->data);
中序*/
preorder(t->rchild);
/*printf("%c",t->data);
后序*/
}
}
/*求深度*/
int
depth(bitree
t){
int
depthval,depl,depr;
if(!t)
depthval=0;
else{
depl=depth(t->lchild);
depr=depth(t->rchild);
depthval=1+(depl>depr?depl:depr);
}
return
depthval;
}
/*求叶子数*/
int
countleaf(bitree
t){
int
count=0;
if(!t)
count=0;
else
if((!t->lchild)&&(!t->rchild))
count++;
else
count=countleaf(t->lchild)+countleaf(t->rchild);
return
count;
}
/*主函数*/
main(){
bitree
t=NULL;
printf("\nplease
input
a
tree:");
t=create(t);
preorder(t);
printf("\ndepth:%d\nleave:%d\n",depth(t),countleaf(t));
system("pause");
}
程序以调试通过！！！！！

谁能够帮咱编一段c语言程序,要求如下：创建二叉树,并遍历

数据结构这本书全有，先中后序是一种搜索方法，先中先序也是
路过``
创建并中序遍历输出
#include

#include

typedef enum{Link,Thread} PointerTag; //指针标志

typedef int DataType;

typedef struct BiThreTree{ //定义结点元素

PointerTag LTag,RTag;

DataType data;

struct BiThreTree *lchild,*rchild;

}BiThreTree;

BiThreTree *pre; //全局变量，用于二叉树的线索化

BiThreTree *CreateTree() //按前序输入建立二叉树

{

BiThreTree *T;

DataType e;

scanf("%d",&e);

if(e==0)

T=NULL;

else

{T=(BiThreTree *)malloc(sizeof(BiThreTree));

T->data=e;

T->LTag=Link; //初始化时指针标志均为Link

T->RTag=Link;

T->lchild=CreateTree();

T->rchild=CreateTree();

}

return T;

}

void InThread(BiThreTree *T)

{

BiThreTree *p;

p=T;

if(p)

{

InThread(p->lchild);

if(!p->lchild)

{ p->LTag=Thread;

p->lchild=pre;

}

if(!pre->rchild)

{ pre->RTag=Thread;

pre->rchild=p;

}

pre=p;

InThread(p->rchild);

}

}

BiThreTree *InOrderThrTree(BiThreTree *T) //中序线索化二叉树

{

BiThreTree *Thre; //Thre为头结点的指针

Thre=(BiThreTree *)malloc(sizeof(BiThreTree));

Thre->lchild=T;

Thre->rchild=Thre;

pre=Thre;

InThread(T);

pre->RTag=Thread;

pre->rchild=Thre;

Thre->rchild=pre;

return Thre;

}

void InThrTravel(BiThreTree *Thre) //中序遍历二叉树

{

BiThreTree *p;

p=Thre->lchild;

while(p!=Thre) //指针回指向头结点时结束

{

while(p->LTag==Link)

p=p->lchild;

printf("%4d",p->data);

while(p->RTag==Thread&&p->rchild!=Thre)

{p=p->rchild;

printf("%4d",p->data);

}

p=p->rchild;

}

}

int main()

{

BiThreTree *T,*Thre;

T=CreateTree();

Thre=InOrderThrTree(T);

InThrTravel(Thre);

system("pause");

}

第二个问题我看不懂。。。什么叫先中后序？

← 上一篇: fgets用法,fgets函数用法下一篇: css3动画效果库,如何在游戏网页中实现动画效果→

二叉树遍历代码c语言,求c语言数据结构二叉树的建树，前序遍历，输出树的代码，能用采纳。

二叉树遍历代码c语言,求c语言数据结构二叉树的建树，前序遍历，输出树的代码，能用采纳。详细介绍

知识分享相关文章：

网站数据信息