本文目录一览：
- 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;
}
