建立二叉树的二叉链表表示，实现二叉树的先序、中序、后序和按层次遍历，统计并输出结点个数。
文件 main.cpp 代码如下：
#include // malloc()等
#include // 标准输入输出头文件，包括EOF(=^Z或F6)，NULL等
#include // atoi()，exit()
#include // 数学函数头文件，包括floor()，ceil()，abs()等
#define ClearBiTree DestroyBiTree // 清空二叉树和销毁二叉树的操作一样
typedef struct BiTNode
{
int data; // 结点的值
BiTNode *lchild,*rchild; // 左右孩子指针
}BiTNode,*BiTree;
int Nil=0; // 设整型以0为空
void visit(int e)
{ printf("%d ",e); // 以整型格式输出
}
void InitBiTree(BiTree &T)
{ // 操作结果：构造空二叉树T
T=NULL;
}
void CreateBiTree(BiTree &T)
{ // 算法6.4：按先序次序输入二叉树中结点的值(可为字符型或整型，在主程中定义)，
// 构造二叉链表表示的二叉树T。变量Nil表示空(子)树。修改
int number;
scanf("%d",&number); // 输入结点的值
if(number==Nil) // 结点的值为空
T=NULL;
else // 结点的值不为空
{ T=(BiTree)malloc(sizeof(BiTNode)); // 生成根结点
if(!T)
exit(OVERFLOW);
T->data=number; // 将值赋给T所指结点
CreateBiTree(T->lchild); // 递归构造左子树
CreateBiTree(T->rchild); // 递归构造右子树
}
}
void DestroyBiTree(BiTree &T)
{ // 初始条件：二叉树T存在。操作结果：销毁二叉树T
if(T) // 非空树
{ DestroyBiTree(T->lchild); // 递归销毁左子树，如无左子树，则不执行任何操作
DestroyBiTree(T->rchild); // 递归销毁右子树，如无右子树，则不执行任何操作
free(T); // 释放根结点
T=NULL; // 空指针赋0
}
}
void PreOrderTraverse(BiTree T,void(*Visit)(int))
{ // 初始条件：二叉树T存在，Visit是对结点操作的应用函数。修改算法6.1
// 操作结果：先序递归遍历T，对每个结点调用函数Visit一次且仅一次
if(T) // T不空
{ Visit(T->data); // 先访问根结点
PreOrderTraverse(T->lchild,Visit); // 再先序遍历左子树
PreOrderTraverse(T->rchild,Visit); // 最后先序遍历右子树
}
}
void InOrderTraverse(BiTree T,void(*Visit)(int))
{ // 初始条件：二叉树T存在，Visit是对结点操作的应用函数
// 操作结果：中序递归遍历T，对每个结点调用函数Visit一次且仅一次
if(T)
{ InOrderTraverse(T->lchild,Visit); // 先中序遍历左子树
Visit(T->data); // 再访问根结点
InOrderTraverse(T->rchild,Visit); // 最后中序遍历右子树
}
}
void PostOrderTraverse(BiTree T,void(*Visit)(int))
{ // 初始条件：二叉树T存在，Visit是对结点操作的应用函数
// 操作结果：后序递归遍历T，对每个结点调用函数Visit一次且仅一次
if(T) // T不空
{ PostOrderTraverse(T->lchild,Visit); // 先后序遍历左子树
PostOrderTraverse(T->rchild,Visit); // 再后序遍历右子树
Visit(T->data); // 最后访问根结点
}
}
void main()
{
BiTree T;
InitBiTree(T); // 初始化二叉树T
printf("按先序次序输入二叉树中结点的值,输入0表示节点为空，输入范例：1 2 0 0 3 0 0
");
CreateBiTree(T); // 建立二叉树T
printf("先序递归遍历二叉树：
");
PreOrderTraverse(T,visit); // 先序递归遍历二叉树T
printf("
中序递归遍历二叉树：
");
InOrderTraverse(T,visit); // 中序递归遍历二叉树T
printf("
后序递归遍历二叉树：
");
PostOrderTraverse(T,visit); // 后序递归遍历二叉树T
}
额，我不知道你用的什么语言，我就先写个先序，中序，后序的遍历把（我用的JAVA语言）
public class BiTree {
private BiTreeNode root;
private void preOrder(BiTreeNode t,Visit vs){
if(t!=null){
vs.print(t.data);
preOrder(t.getLeft(),vs);
preOrder(t.getRight(),vs);
}
}
private void inOrder(BiTreeNode t,Visit vs){
if(t!=null){
inOrder(t.getLeft(),vs);
vs.print(t.data);
inOrder(t.getRight(),vs);
}
}
private void postOrder(BiTreeNode t,Visit vs){
if(t!=null){
postOrder(t.getLeft(),vs);
postOrder(t.getRight(),vs);
vs.print(t.data);
}
}
public void preOrder(Visit vs){
preOrder(root,vs);
}
public void inOrder(Visit vs){
inOrder(root,vs);
}
public void postOrder(Visit vs){
postOrder(root,vs);
}
}
public class Visit {
public void print(Object item){
System.out.print(item+" ");
}
}
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define Max 20 //结点的最大个数
typedef struct node{
char data;
struct node *lchild;
struct node *rchild;
}BTNode; //自定义二叉树的结点类型
typedef BTNode *BTree; //定义二叉树的指针
int NodeNum,leaf; //NodeNUm为结点数，leaf为叶子数
BTree CreatBTree(void)
{BTree T;
char ch;
if((ch=getchar())=='#')
return(NULL); //读入#，返回空指针
else{
T=(BTNode *)malloc(sizeof(BTNode));//生成结点
T->data=ch;
T->lchild=CreatBTree();//构造左子树
T->rchild=CreatBTree();//构造右子树
return(T);
}
}
void Preorder(BTree T) //先序遍历
{
if(T){
printf("%c",T->data);//访问结点
Preorder(T->lchild);//先序遍历左子树
Preorder(T->rchild);//先序遍历右子树
}
}
void Inorder(BTree T)//中序遍历
{
if(T)
{
Inorder(T->lchild);//中序遍历左子树
printf("%c",T->data);//访问结点
Inorder(T->rchild);//中序遍历右字树
}
}
void Postorder(BTree T)//后序遍历
{
if(T)
{
Postorder(T->lchild);
Postorder(T->rchild);
printf("%c",T->data);
}
}
int TreeDepth(BTree 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;
return(max+1);
}
else return(0);
}
void Levelorder(BTree T)//层次遍历二叉树
{
int front=0,rear=1;
BTNode *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->rchild;//右子树入队
}
}
}
void main()
{
BTree root;
int i,depth;
printf("\n");
printf("创建二叉树，请输入完全二叉树的先序序列，用#代表虚结点:");
root=CreatBTree();//返回根结点
do{
printf("********************SELECT********************\n");
printf("\t1:先序遍历\n");
printf("\t2:中序遍历\n");
printf("\t3:后序遍历\n");
printf("\t4:深度、结点数、叶子数\n");
printf("\t5:层次遍历\n");
printf("备注：选择层次遍历之前，需要先选择4，求出该树的结点数。");
printf("\t0:Exit\n");
printf("\t*********************************************\n");
scanf("%d",&i);//输入菜单序号
switch(i)
{
case 1:printf("先序遍历结果为:");
Preorder(root);
break;
case 2:printf("中序遍历结果为:");
Inorder(root);
break;
case 3:printf("后序遍历结果为:");
Postorder(root);
break;
case 4:depth=TreeDepth(root);
printf("深度=%d 结点数=%d",depth,NodeNum);
printf("叶子数=%d",leaf);
break;
case 5:printf("层次遍历为:");
Levelorder(root);
break;
default:exit(1);
}
printf("\n");
}
while(i!=0);
}
typedef struct node
{
char data;
struct node *lchild,*rchild;
}bitree;
bitree *root=NULL;
//创建树
bitree *CreateTree(char *sInPut)
{
bitree *root,*s;
bitree *Q[128];
int front,rear;
root=NULL;
front=1;
rear=0;
char temp[128],*p;
memset(temp,0,128);
strcpy(temp,sInPut);
p=temp;
while(strlen(p)>0)
{
s=NULL;
if(*p!='@')
{
s=(bitree*)malloc(sizeof(bitree));
s->data=*p;
s->lchild=NULL;
s->rchild=NULL;
}
rear++;
Q[rear]=s;
if(rear==1)
{
root=s;
}
else
{
if(s && Q[front])
{
if(rear%2==0)
Q[front]->lchild=s;
else
Q[front]->rchild=s;
}
if(rear%2==1) front++;
}
p+=2;
}
return root;
}
//释放树
void freetree(bitree *root)
{
if(root!=NULL)
{
freetree(root->lchild);
freetree(root->rchild);
free(root);
}
}
//前序遍历
void preorder(bitree *root)
{
if(root!=NULL)
{
printf("%c\t",root->data);
preorder(root->lchild,sOutPut);
preorder(root->rchild,sOutPut);
}
}
//中序遍历
void inorder(bitree *root)
{
if(root!=NULL)
{
inorder(root->lchild,sOutPut);
printf("%c\t",root->data);
inorder(root->rchild,sOutPut);
}
}
//后序遍历
void postorder(bitree *root)
{
if(root!=NULL)
{
postorder(root->lchild,sOutPut);
postorder(root->rchild,sOutPut);
printf("%c\t",root->data);
}
}
//层次遍历
void PrintTree(bitree *root)
{
CString sOutPut;
char temp[128];
bitree *Q[128],*s;
int front,rear;
front=0;
rear=0;
sOutPut.Empty();
Q[rear++]=root;
while(rear>front)
{
printf("%c\t",Q[front]->data);
sOutPut=temp;
s=Q[front++];
if(s->lchild!=NULL)
Q[rear++]=s->lchild;
if(s->rchild!=NULL)
Q[rear++]=s->rchild;
}
}
//树叶子数
void countleaf(bitree *root,int &count)
{ if(root!=NULL)
{ if((root->lchild==NULL)&&(root->rchild==NULL))
{ count++;
return;
}
countleaf(root->lchild,count);
countleaf(root->rchild,count);
}
}
//树深度
void treedepth(bitree *root,int l,int &h)
{ if(root!=NULL)
{ l=l+1;
if(l>h) h=l;
treedepth(root->lchild,l,h);
treedepth(root->rchild,l,h);
}
}
总 叙2:油画框用定做的比较好,一般是木头框!绷上油画布(麻布)!(根据自己想画的大小可以任意做).然后刷三次乳白胶!一定要刷到位!待干后就可以画了!这些东西在美术用品店有售!大学附近也有售!
为感君王辗转思，遂教方士殷勤觅。 把自己的厚度给积累起来，
怎么建立一棵以二叉链表方式存储的二叉树,并且对其进行遍历(先序、中...
答：InitBiTree(T);//初始化二叉树printf("构造二叉树后,树空否?%d(1,是,0否).树的深度=%d.\n",BiTreeEmpty(T),BiTreeDepth(T));CreateBiTree(T);//建立二叉树Tprintf("构造二叉树后,树空否?%d(1,是,0否).树的深度=%d.\n",BiTreeEmpty(T),BiTreeDepth(T));e1=Root(T);//e1为二叉树T的...
数据结构二叉树的基本操作~~~
答：用递归的方法实现以下算法：1．以二叉链表表示二叉树，建立一棵二叉树；2．输出二叉树的前序遍历结果；3．输出二叉树的中序遍历结果；4．输出二叉树的后序遍历结果；5．统计二叉树的叶结点个数；6．统计二叉树的结点个数；7．计算二叉树的深度。8．交换二叉树每个结点的左孩子和右孩子；include <...
设二叉树的存储结构为二叉链表,试写出算法(C函数):将所有结点的左右子树...
答：1、以二叉链表作存储结构，试编写前序、中序、后序及层次顺序遍历二叉树的算法。define M 10 typedef int DataType;/*元素的数据类型*/ typedef struct node { DataType data;struct node *lchild,*rchild;}BitTNode,*BiTree;int front=0,rear=0;BitTNode *que[10];BitTNode *creat(){Bi...
二叉树的建立
答：include "stdlib.h"//二叉链表结点定义 struct tree { int data;struct tree *lchild;struct tree *rchild;};// 先序建立二叉树 struct tree *create(struct tree *BT,int k){ struct tree *p;int x;p=(struct tree *)malloc(sizeof(struct tree));printf("输入结点的整数值（0表示空） :...
请问怎么创建完全二叉树(用字母表示节点)(用顺序方式存储),急求!!!
答：这个简单啊 // c6-2.h 二叉树的二叉链表存储表示 typedef struct BiTNode { TElemType data; BiTNode *lchild,*rchild; // 左右孩子指针 }BiTNode,*BiTree; // arith.cpp 二叉树的二叉链表存储(存储结构由c6-2.h定义)的基本操作,包括算法6.1～6.4 #define ClearBiTree DestroyBiTree // 清空二叉树和销毁二...
...设计一个算法由此数组得到该完全二叉树的二叉链表结构.用c++写_百度...
答：//中序遍历二叉树 void MidOrderTravel(BTNode *root){ if(root != NULL){ MidOrderTravel(root->left);cout<<root->data<<" ";MidOrderTravel(root->right);} }//根据二叉树的顺序存储结构，生成二叉树的二叉链表结构 BTNode *CreateBinaryTree(BTNode *nodes[], int size){ BTNode *root;...
采用二叉链表作为存储结构,完成二叉树的建立,前序、中序和后序遍历的...
答：//后序遍历二叉树 void lasTraverse(BiTree T){ if(T==NULL){return;} lasTraverse(T->Lchild);lasTraverse(T->Rchild);printf("%d ",T->data);} //求二叉树的深度 int TreeDeep(BiTree T){ int deep=0;if(T){ int leftdeep=TreeDeep(T->Lchild);int rightdeep=TreeDeep(T->...
以二叉链表作存储结构,编写二叉树深度的递归算法(c++语言)
答：给你一个完整的例子吧。学习一下#include <stdio.h> include <malloc.h> include <stdlib.h> define OK 1 define ERROR 0 define OVERFLOW -2 define MAX(a,b) (a>b?a:b)typedef char TElemType;typedef int Status;//二叉树的二叉链表存储结构 typedef struct BiTNode{ TElemType data;struct...
假设二叉树以二叉链表作为存储结构,试设计一个计算二叉树叶子结点树的...
答：1、首先要定义两个类：结点类和二叉树类。2、二叉树类的组成：建立树的函数、遍历函数、删除函数。求结点数函数。3、采用递归的思想，遇到标识符表示该结点为空，否则开辟空间创建新结点，同时调用递归开辟左结点和右结点。4、前序遍历函数。5、删除函数的思路：如果当前结点不为空，采用递归访问左结点...
二叉排序树的实现 分别用顺序和二叉链表作存储结构 1)以回车('\n...
答：//===基于先序遍历算法创建二叉树=== //===要求输入先序序列，其中加入虚结点"#"以示空指针的位置=== BinTree CreatBinTree(void){ BinTree T;char ch;if((ch=getchar())=='#')return(NULL); //读入#，返回空指针 else{ T=(BinTNode *)malloc(sizeof(BinTNode)); //生成...
