二叉树的操作及其应用：1、以二叉链表作存储结构，试编写前序、中序、后序及层次顺序遍历二叉树的算法。 2
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()
{BitTNode *t;
DataType x;
scanf("%d",&x);
if(x==0) t=NULL;
else{ t=(BitTNode *)malloc(sizeof(BitTNode));
t->data=x;
t->lchild=creat();
t->rchild=creat();
}
return(t);
}/*creat*/
/* 前序遍历二叉树t */
void preorder(BiTree t)
{ if(t!=NULL)
{ printf("%4d",t->data);
preorder(t->lchild);
preorder(t->rchild);
}
}
/* 中序遍历二叉树t */
void inorder(BiTree t)
{ if(t!=NULL)
{ inorder(t->lchild);
printf("%4d",t->data);
inorder(t->rchild);
}
}
/* 后序遍历二叉树t */
void postorder(BiTree t)
{ if(t!=NULL)
{ postorder(t->lchild);
postorder(t->rchild);
printf("%4d",t->data);
}
}
void enqueue(BitTNode *t)
{if (front!=(rear+1)%M)
{ rear=(rear+1)%M;
que[rear]=t;
}
}/*enqueue*/
BitTNode * delqueue()
{ if(front==rear)return NULL;
{ front=(front+1)%M;
return (que[front]);
}
}/*delqueue*/
/* 按层次遍历二叉树t */
void levorder(BiTree t)
{ BitTNode *p;
if(t!=NULL)
{ enqueue(t);
while (front!=rear)
{ p=delqueue();
printf("%4d",p->data);
if(p->lchild!=NULL) enqueue(p->lchild);
if(p->rchild!=NULL) enqueue(p->rchild);
}
}
}/* levorder */
main()
{BitTNode *root;
root=creat();
printf("
按先序遍历次序生成的二叉树");
printf("
前序遍历二叉树");
preorder(root);
printf("
中序遍历二叉树");
inorder(root);
printf("
后序遍历二叉树");
postorder(root);
printf("
层次顺序遍历二叉树");
levorder(root);
}
2、以二叉链表作存储结构，试编写计算二叉树深度、所有结点总数、叶子结点数、双孩子结点个数、单孩子结点个数的算法
#include <stdio.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node
{
ElemType data;
struct node *left,*right;
} BTree;
BTree * createbt( )
{ BTree *q;
struct node1 *s[30];
int j,i,x;
printf("建立二叉树，输入结点对应的编号和值,编号和值之间用逗号隔开
");
printf("i,x = ");
scanf("%d,%c",&i,&x);
while(i != 0 && x != '$')
{ q = (BTree*)malloc(sizeof(BTree)); /*建立一个新结点q*/
q->data = x; q->left = NULL; q->right = NULL;
s[i] = q; /*q新结点地址存入s指针数组中*/
if(i != 1) /*i = 1，对应的结点是根结点*/
{ j = i / 2; /*求双亲结点的编号j*/
if(i % 2 == 0)
s[j]->left = q; /*q结点编号为偶数则挂在双亲结点j的左边*/
else
s[j]->right = q; /*q结点编号为奇数则挂在双亲结点j的右边*/
}
printf("i,x = ");
scanf("%d,%c",&i,&x);
}
return s[1]; /*返回根结点地址*/
}
void preorder(BTree *BT)
/* 前序遍历二叉树t */
{ if(BT!=NULL)
{ printf("%4c", BT ->data);
preorder(BT ->left);
preorder(BT ->right);
}
}
int BTreeDepth(BTree *BT)
{
int leftdep,rightdep;
if (BT==NULL)
return(0);
else
{
leftdep=BTreeDepth(BT->left);
rightdep=BTreeDepth(BT->right);
if (leftdep>rightdep)
return(leftdep+1);
else
return(rightdep+1);
}
}
int nodecount(BTree *BT)
{
if (BT==NULL)
return(0);
else
return(nodecount(BT->left)+nodecount(BT->right)+1);
}
int leafcount(BTree *BT)
{
if (BT==NULL)
return(0);
else if (BT->left==NULL && BT->right==NULL)
return(1);
else
return(leafcount(BT->left)+leafcount(BT->right));
}
int notleafcount(BTree *BT)
{
if (BT==NULL)
return(0);
else if (BT->left==NULL && BT->right==NULL)
return(0);
else
return(notleafcount(BT->left)+notleafcount(BT->right)+1);
}
int onesoncount(BTree *BT)
{
if (BT==NULL)
return(0);
else if ((BT->left==NULL && BT->right!=NULL) ||
(BT->left!=NULL && BT->right==NULL))
return(onesoncount(BT->left)+onesoncount(BT->right)+1);
else
return(onesoncount(BT->left)+onesoncount(BT->right));
}
int twosoncount(BTree *BT)
{
if (BT==NULL)
return(0);
else if (BT->left==NULL || BT->right==NULL)
return(twosoncount(BT->left)+twosoncount(BT->right));
else if (BT->left!=NULL && BT->right!=NULL)
return(twosoncount(BT->left)+twosoncount(BT->right)+1);
}
main()
{
BTree *B;
B=creatree();
printf("
按先序遍历次序生成的二叉树");
preorder(B);
printf("
二叉树深度:%d
",BTreeDepth(B));
printf("总结点个数:%d
",nodecount(B));
printf("叶子结点个数:%d
",leafcount(B));
printf("非叶子结点个数:%d
",notleafcount(B));
printf("具有双孩子结点个数:%d
",twosoncount(B));
printf("具有单孩子结点个数:%d
",onesoncount(B));
}
如果还没解决你的问题，可以加我百度HI账号。
#include
#include
#include
using namespace std;
typedef int Elemtype;
typedef struct BiTnode
{
Elemtype data;//数据域
struct BiTnode* Lchild,*Rchild; //左右子树域；
}BiTnode,*BiTree;
int create(BiTree *T)
{
Elemtype ch;
Elemtype temp;
scanf("%d",&ch);
temp=getchar();
if(ch==-1)
{
*T=NULL;
}
else
{
*T=(BiTree)malloc(sizeof(BiTnode) );
if(!(*T))
{
exit(-1);
}
else
{
(*T)->data=ch;
printf("请输入%d的左节点的值",ch);
create(&(*T)->Lchild);
printf("请输入%d的右节点的值",ch);
create(&(*T)->Rchild);
}
}
return 1;
}
void Traverse(BiTree T)//前序遍历二叉树
{
if(NULL==T)
{
return;
}
else
{
printf("%d ",T->data);
Traverse(T->Lchild);
Traverse(T->Rchild);
}
}
//中序遍历二叉树
void midTraverse(BiTree T)
{
if(T==NULL){return;}
midTraverse(T->Lchild);
printf("%d ",T->data);
midTraverse(T->Rchild);
}
//后序遍历二叉树
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->Rchild);
deep=leftdeep>=rightdeep?leftdeep+1:rightdeep+1;
}
return deep;
}
//求二叉树叶子节点个数
int Leafcount(BiTree T,int &num)
{
if(T)
{
if(T->Lchild==NULL&&T->Rchild==NULL)
{
num++;
}
Leafcount(T->Lchild,num);
Leafcount(T->Rchild,num);
}
return num;
}
int main()
{
BiTree T;
BiTree *p=(BiTree*)malloc(sizeof(BiTree));
int deepth=0,num=0;
printf("请输入第一个节点的值，-1代表没有叶节点:
");
create(&T);
printf("先序遍历二叉树：
");
Traverse(T);
printf("
");
printf("中序遍历二叉树:
");
midTraverse(T);
printf("
");
printf("后序遍历二叉树：
");
lasTraverse(T);
printf("
");
deepth=TreeDeep(T);
printf("树的深度:%d
",deepth);
printf("
");
Leafcount(T,num);
printf("二叉树的叶子节点个数为:%d
",num);
printf("
");
return 0;
扩展资料：
二叉链表是树的二叉链表实现方式。
树的二叉链表实现方式：（孩子兄弟表示法）
以二叉链表作为树的存储结构。链表中结点的两个链域分别指向该结点的第一个孩子结点和下一个兄弟结点。
结构描述：
typedef struct CSNode{
ElemType data；
struct CSNode *firstchild ， *netsibling；
} CSNode，* CSTree；
由于二叉树的存储结构比较简单，处理起来也比较方便，所以有时需要把复杂的树，转换为简单的二叉树后再作处理。
#include<malloc.h> // malloc()等
#include<stdio.h> // 标准输入输出头文件，包括EOF(=^Z或F6)，NULL等
#include<stdlib.h> // atoi()，exit()
#include<math.h> // 数学函数头文件，包括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\n");
CreateBiTree(T); // 建立二叉树T
printf("先序递归遍历二叉树：\n");
PreOrderTraverse(T,visit); // 先序递归遍历二叉树T
printf("\n中序递归遍历二叉树：\n");
InOrderTraverse(T,visit); // 中序递归遍历二叉树T
printf("\n后序递归遍历二叉树：\n");
PostOrderTraverse(T,visit); // 后序递归遍历二叉树T
}
/* 我的QQ号为540397154，有什么疑问的话发邮件给我。
作者:佳之星勇:本人真实姓名:ss cel 你用五笔打ss cel 就知道了我的姓名
现居住在长沙
*/
#include<iostream>
using namespace std;
typedef struct BiTNode
{
char data;
struct BiTNode *lchild,*rchild;
}BiTNode;
typedef BiTNode *BiTree;//定义结点类型
//建立二叉树
void CreateBiTree(BiTree &T)
{
char ch;
if((ch=getchar())==' ')//这个代表空格，可换别的字符
T=NULL; //建立空二叉树
else
{
T=(BiTNode *)malloc(sizeof(BiTNode)); //生成一个新结点
T->data=ch;
CreateBiTree(T->lchild); //生成左子树
CreateBiTree(T->rchild); //生成右子树
}
}
void PreOrder(BiTree T)//先序
{
if(T!=NULL)
{
cout<<T->data;
PreOrder(T->lchild);
PreOrder(T->rchild);
}
}
void InOrder(BiTree T)//中序
{
if(T!=NULL)
{
InOrder(T->lchild);
cout<<T->data;
InOrder(T->rchild);
}
}
void PostOrder(BiTree T)//后序
{
if(T!=NULL)
{
PostOrder(T->lchild);
PostOrder(T->rchild);
cout<<T->data;
}
}
int Depth(BiTree T)/* 深度 */
{
if(T==NULL)
return(0);
else
return 1+(Depth(T->lchild)>Depth(T->rchild)? Depth(T->lchild):Depth(T->rchild));
}
void main()//主函数
{
BiTree Ta;
CreateBiTree(Ta);
cout<<"先序遍历:"<<endl;
PreOrder(Ta);
cout<<endl<<"中序遍历:"<<endl;
InOrder(Ta);
cout<<endl<<"后序遍历:"<<endl;
PostOrder(Ta);
cout<<endl<<"深度为";
cout<<Depth(Ta)<<endl;
}
/*你输入如下：
ABD**EG*J***C*FHK**L**IM***
（其中*代表空格，输入时*代表空格）
*/
二叉树的操作及其应用:1、以二叉链表作存储结构,试编写前序、中序...
答：InitBiTree(T); // 初始化二叉树T printf("按先序次序输入二叉树中结点的值,输入0表示节点为空，输入范例：1 2 0 0 3 0 0\n");CreateBiTree(T); // 建立二叉树T printf("先序递归遍历二叉树：\n");PreOrderTraverse(T,visit); // 先序递归遍历二叉树T printf("\n中序递归遍历二叉...
二叉树怎么操作?
答：（1）以先序递归遍历思想建立二叉树。①建立二叉树的根结点；②先序建立二叉树的左子树；③先序建立二叉树的右子树。（2）构造二叉树的操作算法。输入一个二叉树的先序序列，构造这棵二叉树。为了保证唯一地构造出所希望的二叉树，在键入这棵树的先序序列时，需要在所有空二叉树的位置上填补一个特殊...
数据结构二叉树的基本操作~~~
答：1．以二叉链表表示二叉树，建立一棵二叉树；2．输出二叉树的前序遍历结果；3．输出二叉树的中序遍历结果；4．输出二叉树的后序遍历结果；5．统计二叉树的叶结点个数；6．统计二叉树的结点个数；7．计算二叉树的深度。8．交换二叉树每个结点的左孩子和右孩子；include <malloc.h> include <stdio.h...
二叉排序树的应用
答：二叉排序树（Binary Sort Tree），首先它是一棵树，“二叉”这个描述已经很明显了，就是树上的一根树枝开两个叉，于是递归下来就是二叉树了（下图所示），而这棵树上的节点是已经排好序的，具体的排序规则如下：若左子树不空，则左子树上所有节点的值均小于它的根节点的值 若右子树不空，则右字数上...
二叉树是什么?
答：二叉树的基本操作：(1)INITIATE(BT ） 初始化操作。置 BT为空树。(2)ROOT(BT)\ROOT(x) 求根函数。求二叉树 BT的根结点或求结点 x所在二叉树的根结点。若 BT是空树或 x不在任何二叉树上，则函数值为 “空 ”。(3)PARENT(BT,x) 求双亲函数。求二叉树 BT中结点 x的双亲结点。若结点 x...
二叉排序树的应用
答：回答：当用线性表作为表的组织形式时,可以有三种查找法。其中以二分查找效率最高。但由于二分查找要求表中结点按关键字有序,且不能用链表作存储结构,因此,当表的插入或删除操作频繁时,为维护表的有序性,势必要移动表中很多结点。这种由移动结点引起的额外时间开销,就会抵消二分查找的优点。也就是说,...
树和二叉树的运行与操作
答：转化：直觉上，最简单的二叉树存储方式。首先，提供个满二叉树大小的数组，然后其中数值按完全二叉树存储。显然，此种顺序存储方法：第i号（这里编号指对应的完全二叉树的位序）结点的左右孩子一定保存在第2i及2i+1号单元中。故此，为兼顾存储的直观与遍历等操作的方便，从顺序数组向左右子节点存储方式...
二叉树操作
答：struct BiTNode //二叉树结点类型{ int data; //数据 int tem1,tem2; //辅助数据(实习题不用) BiTNode *left; //左子树指针 BiTNode *right; //右子树指针};BiTNode *Tree; //本程序操作的二叉树根指针const max=100;int elem[max]; //存放原始数据//从键盘输入个数和随机数种子,在数组elem中生成...
二叉树是什么
答：例如，在计算机科学中，我们常常使用二叉搜索树来存储有序数据。在这种类型的二叉树中，每个节点的左子树中的所有值都小于该节点的值，而右子树中的所有值都大于该节点的值。这种结构允许我们在对数时间内进行搜索、插入和删除操作。此外，表达式树、解析树等也是二叉树的典型应用。总的来说，二叉树是一...
“二叉树”是什么?
答：1.二叉树的递归定义 二叉树(BinaryTree)是n(n≥0)个结点的有限集，它或者是空集(n=0)，或者由一个根结点及两棵互不相交的、分别称作这个根的左子树和右子树的二叉树组成。2．二叉树的五种基本形态 二叉树可以是空集；根可以有空的左子树或右子树；或者左、右子树皆为空。二叉树的五种基本形态...
