二叉树按层输出c语言,C语言二叉树怎么输入数据

本文目录一览：

• 1、请问如何用c语言实现二叉树的按层录入
• 2、实现二叉树的层次遍历用c语言！不要c++
• 3、用c语言实现二叉树的程序，可以输入输出和遍历
• 4、用C语言编程 ：建立三层二叉树，先根遍历输出，在线求高手
• 5、c语言广义表形式输入二叉树，从下到上按层打印改树； 不知道哪错了，请各位大侠帮帮忙！

请问如何用c语言实现二叉树的按层录入

#includestdio.h

#includestdlib.h

#includestring.h

#define MaxSize 1024

typedef struct node

{

char data;

struct node *lchild;

struct node *rchild;

}BTnode;

static char a[1024];

void create(BTnode *b,int m,int i)

{

if(ima[i]!=’ ‘)

{

b=(BTnode*)malloc(sizeof(BTnode));

b-data=a[i];

b-lchild=b-rchild=NULL;

create(b-lchild,m,2*i);

create(b-rchild,m,2*i+1);

}

}

void print(BTnode *b)

{

BTnode *p=b;

if(p!=NULL)

{

printf(“%c”,p-data);

if(p-lchild!=NULL||p-rchild!=NULL)

{

printf(“(“);

print(b-lchild);

if(p-rchild!=NULL)

{

printf(“,”);

print(b-rchild);

}

printf(“)”);

}

}

}

int main()

{

BTnode *b;

int j,m=1;

char s[1024],*p;

printf(“以字符串形式输入第一层节点（根节点）：\n”);

gets(s);

while(strlen(s)!=0)

{

j=m;

p=s;

while(m2*j)

{

a[m]=*p;

p++;

m++;

}

printf(“以字符串形式输入下一层节点（空节点以空格表示）：\n”);

gets(s);

}

create(b,m,1);

printf(“以二叉链表表示形式输出二叉树：\n”);

print(b);

printf(“\n\n”);

system(“pause”);

}

实现二叉树的层次遍历用c语言！不要c++

#includestdio.h

#includemalloc.h

//***********************************************************************

//定义二叉树

typedef struct tree{

char data;

struct tree *lchild,*rchild ;

}Tree,*Ptree;

//***********************************************************************

//定义队列

typedef struct queue_{

Ptree data[100];

int front,rear;

}Dqueue,*Pqueue;

//***********************************************************************

//建立二叉树 先根建立

Ptree CreateTree(Ptree N)

{

Ptree T=NULL ;

char c;

c = getchar();

if(c==’#’)

return NULL;

T = (Ptree)malloc(sizeof(tree));

T-data = c;

T-lchild=CreateTree(T);

T-rchild=CreateTree(T);

return T;

}

//删除二叉树

void DeleteTree(Ptree *T)

{

if(*T ==NULL)

return ;

if((*T)-lchild == NULL (*T)-rchild == NULL)

{

free(*T);

*T = NULL;

}

else

{

DeleteTree((*T)-lchild);

DeleteTree((*T)-rchild);

}

}

//***********************************************************************

//初始化队列

Pqueue initQueue()

{

Pqueue p;

p=(Pqueue)malloc(sizeof(Dqueue));

if(p)

{

p-front=0;

p-rear=0;

}

return p;

}

//***********************************************************************

//判断队列是否为空

int emptyQueue(Pqueue p)

{

if(p-front==p-rear)

return 1;

else

return 0;

}

//***********************************************************************

//入队

void inQueue(Pqueue p,Ptree t)

{

p-rear=(p-rear+1)%100;

p-data[p-rear]=t;

}

//***********************************************************************

//出队

void outQueue(Pqueue p,Ptree* t)

{

p-front=(p-front+1)%100;

*t=p-data[p-front];

}

//***********************************************************************

//层次遍历

void levelOrder(Ptree t)

{

Ptree p=t;

Pqueue Q=NULL;

if(p)

{

Q=initQueue();//初始化队列

printf(“%c”,p-data);

inQueue(Q,p);

while(!emptyQueue(Q))//当队列不为空

{

outQueue(Q,p);//出队

if(p-lchild)

{

printf(“%c”,p-lchild-data);

inQueue(Q,p-lchild);//进队

}

if(p-rchild)

{

printf(“%c”,p-rchild-data);

inQueue(Q,p-rchild);//进队

}

}

free(Q);

}

}

int main()

{

Ptree t;

printf(“先根建立二叉树：（结点值为字符，空结点以#表示）”);

t = CreateTree(NULL);

printf(“层遍历二叉树：\n”);

levelOrder(t);

DeleteTree(t);

return 0;

}

用c语言实现二叉树的程序，可以输入输出和遍历

#include stdio.h

#include stdlib.h

#include iostream.h

const int MaxLength=10;//结点个数不超过10个

typedef struct tree

{

char data;

struct tree *lchild,*rchild;

}tree;

//先序递归 建立二叉树

void Createbitree(tree* T)

{

char ch;

ch=getchar();

if(ch==’#’)

T=NULL;

else

{

T=(tree*)malloc(sizeof(tree));

T-data =ch;

Createbitree(T-lchild );

Createbitree(T-rchild );

}

}

//先序递归遍历

void PreOrderTraverse(tree* T)

{

if(T)

{

coutT-data;

PreOrderTraverse(T-lchild);

PreOrderTraverse(T-rchild);

}

}

//中序递归遍历

void InOrderTraverse(tree* T)

{

if(T)

{

InOrderTraverse(T-lchild);

coutT-data;

InOrderTraverse(T-rchild);

}

}

void PostOrderTraverse(tree* T)

{

if(T)

{

PostOrderTraverse(T-lchild);

PostOrderTraverse(T-rchild);

coutT-data;

}

}

//层序遍历

void LevelOrderTraverse(tree* T)

{

tree* Q[MaxLength];

int front=0,rear=0;

tree* p;

if(T)//根结点入队

{

Q[rear]=T;

rear=(rear+1)%MaxLength;

}

while(front!=rear)

{

p=Q[front]; //队头元素出队

front=(front+1)%MaxLength;

coutp-data;

if(p-lchild)//左孩子不为空，入队

{

Q[rear]=p-lchild;

rear=(rear+1)%MaxLength;

}

if(p-rchild)//右孩子不为空，入队

{

Q[rear]=p-rchild;

rear=(rear+1)%MaxLength;

}

}

}

//主函数

void main()

{

cout”请按先序次序输入二叉树的数据:”endl;

tree* T;

Createbitree(T);

cout”二叉树的先序序列为:”endl;

PreOrderTraverse(T);

coutendl”二叉树的中序序列为:”endl;

InOrderTraverse(T);

coutendl”二叉树的后序序列为:”endl;

PostOrderTraverse(T);

coutendl”二叉树的层序序列为:”endl;

LevelOrderTraverse(T);

coutendl;

}

比如 1

2 3

4 5 6 7

按先序输入是124##5##36##7##

用C语言编程 ：建立三层二叉树，先根遍历输出，在线求高手

A

(B C)

(D E) (F G)

以这课树为例

#include stdio.h

#include stdlib.h

typedef char Elem;

typedef struct Node

{

Elem data;

struct Node *pLchild;

struct Node *pRchild;

}BTreeNode, *BTree;

BTree CreateBTree(BTree T, Elem *str)//创建二叉树

{

static int i = 0;

if (‘0’ == str[i])

{

T = NULL;

}

else

{

T = (BTree) malloc (sizeof(BTreeNode));

T-data = str[i++];

T-pLchild = CreateBTree(T-pLchild, str);

i++;

T-pRchild = CreateBTree(T-pRchild, str);

}

return T;

}

void PostTraverseBTree(BTree T)//后序

{

if (NULL != T)

{

PostTraverseBTree(T-pLchild);

PostTraverseBTree(T-pRchild);

printf(“%c “, T-data);

}

}

void InTraverseBTree(BTree T)//中序

{

if (NULL != T)

{

InTraverseBTree(T-pLchild);

printf(“%c “, T-data);

InTraverseBTree(T-pRchild);

}

}

void PreTraverseBTree(BTree T)//先序

{

if (NULL != T)

{

printf(“%c “, T-data);

PreTraverseBTree(T-pLchild);

PreTraverseBTree(T-pRchild);

}

}

int main(void)

{

BTree T = NULL;

Elem str[] = “ABD00E00CF00G00”;

T = CreateBTree(T, str);

printf(“\n\n”);

printf(“先序遍历:\n”);

PreTraverseBTree(T);

printf(“\n\n”);

printf(“中序遍历:\n”);

InTraverseBTree(T);

printf(“\n\n”);

printf(“后序遍历:\n”);

PostTraverseBTree(T);

printf(“\n\n”);

}

c语言广义表形式输入二叉树，从下到上按层打印改树； 不知道哪错了，请各位大侠帮帮忙！

太长了 懒得看 给你看我的把

#include “stdio.h”

#include “malloc.h”

#define MaxSize 20

typedef struct tnode

{

int data;

struct tnode *lchild,*rchild;

}BTNode;

//建立二叉树运算算法

void CreatBTree(BTNode *bt,char *str)

{

BTNode *St[MaxSize],*p=NULL;

int top=-1,k,j=0;

char ch;

bt=NULL; //建立的二叉树初始化时为空

ch=str[0];

while(ch!=’\0′)

{

switch(ch)

{

case ‘(‘: top++;St[top]=p;k=1;break; //为左孩子结点

case ‘)’: top–;break;

case ‘,’: k=2;break; //为右孩子结点

default : p=(BTNode *)malloc(sizeof(BTNode));

p-data =ch;p-lchild =p-rchild =NULL;

if(bt==NULL) //p为二叉树的根结点

bt=p;

else //已建立二叉树根结点

{

switch(k)

{

case 1: St[top]-lchild =p;break;

case 2: St[top]-rchild =p;break;

}

}

}

j++;ch=str[j];

}

}

//求二叉树高度运算算法(递归法)

int BTHeight(BTNode *bt)

{

int lchilddep,rchilddep;

if(bt==NULL) //空树高度为0

return 0;

else

{

lchilddep=BTHeight(bt-lchild);//求左子树的高度

rchilddep=BTHeight(bt-rchild);//求右子树的高度

return (lchilddeprchilddep)?(lchilddep+1):(rchilddep+1);

}

}

//求二叉树结点个数运算算法(递归法)

int NodeCount(BTNode *bt)

{

int num1,num2;

if(bt==NULL) //空树结点个数为0

return 0;

else

{

num1=NodeCount(bt-lchild ); //求出左子树的结点树

num2=NodeCount(bt-rchild ); //求出右子树的结点树

return (num1+num2+1);

}

}

//求二叉树叶子结点个数运算算法(递归法)

int LeafCount(BTNode *bt)

{

int num1,num2;

if(bt==NULL)

return 0; //空树叶子结点个数为0

else if(bt-lchild ==NULLbt-rchild ==NULL)

return 1; //若为叶子结点返回1

else

{

num1=LeafCount(bt-lchild ); //求出左子树的叶子结点树

num2=LeafCount(bt-rchild ); //求出右子树的叶子结点树

return num1+num2;

}

}

//以括号表示法输出二叉树运算算法(递归法)

void DispBTree(BTNode *bt)

{

if(bt!=NULL)

{

printf(“%c”,bt-data);

if(bt-lchild !=NULL || bt-rchild!=NULL)

{

printf(“(“);

DispBTree(bt-lchild ); //以递归法处理左子树

if(bt-rchild !=NULL)

printf(“,”);

DispBTree(bt-rchild ); //以递归法处理右子树

printf(“)”);

}

}

}

//先序遍历

void PreOrder(BTNode *bt)

{

if(bt!=NULL)

{

printf(“%c”,bt-data );

PreOrder(bt-lchild );

PreOrder(bt-rchild );

}

}

//中序遍历

void InOrder(BTNode *bt)

{

if(bt!=NULL)

{

InOrder(bt-lchild );

printf(“%c”,bt-data );

InOrder(bt-rchild );

}

}

//后序遍历

void PostOrder(BTNode *bt)

{

if(bt!=NULL)

{

PostOrder(bt-lchild );

PostOrder(bt-rchild );

printf(“%c”,bt-data );

}

}

int main() //主函数

{

BTNode *bt;

CreatBTree(bt,”A(B(D,E(G,H),C(,F(I)))”);

printf(“二叉数bt以括号法显示为: “); DispBTree(bt);printf(“\n”);

printf(“先序发遍历二叉数bt为: “); PreOrder(bt); printf(“\n”);

printf(“中序发遍历二叉数bt为: “); InOrder(bt); printf(“\n”);

printf(“后序发遍历二叉数bt为: “); PostOrder(bt); printf(“\n”);

printf(“二叉数bt的高度为： %d\n”, BTHeight(bt));

printf(“二叉数bt的结点数为： %d\n”, NodeCount(bt));

printf(“二叉数bt的叶子结点数为： %d\n”, LeafCount(bt));

printf(“\n”);

return 0;

}