编写一个程序，实现二叉树的各种基本运算

Posted 2023-04-23

编写一个程序，实现二叉树的各种基本运算，并在此基础上设计一个主程序完成如下功能：
（1）输入由文件指定的二叉树
（2）输出指定结点的子结点值
（3）输出二叉树左、右子树的深度
（4）判断二叉树是否为完全二叉树并输出叶结点
请大神帮忙，不要百度的，我要C++编写的，求大神帮忙，小女子定当万分感激~~~

//文件名:exp7-1.cpp
#include <stdio.h>
typedef char ElemType;
typedef struct node

ElemType data; //数据元素
struct node *lchild; //指向左孩子
struct node *rchild; //指向右孩子
BTNode;
extern void CreateBTNode(BTNode *&b,char *str);
extern BTNode *FindNode(BTNode *b,ElemType x);
extern BTNode *LchildNode(BTNode *p);
extern BTNode *RchildNode(BTNode *p);
extern int BTNodeDepth(BTNode *b);
extern void DispBTNode(BTNode *b);
extern int BTWidth(BTNode *b);
extern int Nodes(BTNode *b);
extern int LeafNodes(BTNode *b);
extern void DestroyBTNode(BTNode *&b);
void main()
BTNode *b,*p,*lp,*rp;;
CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
printf("二叉树的基本运算如下:\n");
printf(" (1)输出二叉树:");DispBTNode(b);printf("\n");
printf(" (2)H节点:");
p=FindNode(b,'H');
if (p!=NULL)
lp=LchildNode(p);
if (lp!=NULL)
printf("左孩子为%c ",lp->data);
else
printf("无左孩子 ");
rp=RchildNode(p);
if (rp!=NULL)
printf("右孩子为%c",rp->data);
else
printf("无右孩子 ");

printf("\n");
printf(" (3)二叉树b的深度:%d\n",BTNodeDepth(b));
printf(" (4)二叉树b的宽度:%d\n",BTWidth(b));
printf(" (5)二叉树b的节点个数:%d\n",Nodes(b));
printf(" (6)二叉树b的叶子节点个数:%d\n",LeafNodes(b));
printf(" (7)释放二叉树b\n");
DestroyBTNode(b);
参考技术A

见代码,二叉树的宽度,很奇葩,我的理解是隔了多少个结点,宽度就为多少.

#include<iostream>
using namespace std;
struct node

char value;
node* left;
node* right;
node(char v):value(v),left(NULL),right(NULL)
;

void ConnectTreeNodes(node* pParent, node* pLeft, node* pRight)

    if(pParent)
    
        pParent->left = pLeft;
        pParent->right = pRight;
    

node* CreateTree()

node *pa=new node('a');
node *pb=new node('b');
node *pc=new node('c');
node *pd=new node('d');
node *pe=new node('e');
node *pf=new node('f');
node *pg=new node('g');
node *ph=new node('h');
node *pi=new node('i');
ConnectTreeNodes(pa,pb,pi);
ConnectTreeNodes(pb,pc,pf);
ConnectTreeNodes(pc,pd,pe);
ConnectTreeNodes(pi,pg,ph);
return pa;

int TreeHeight(node* root)

if(!root) return 0;
int left=TreeHeight(root->left);
int right=TreeHeight(root->right);
return 1+(left > right?left : right);

int TreeLeaves(node* root)

if(!root) return 0;
if(!root->left && !root->right)
return 1;
return TreeLeaves(root->left)+TreeLeaves(root->right);

int TreeWidth(node* root)

if(!root) return 0;
if(!root->left && !root->right)
return 1;
return TreeWidth(root->left)+TreeWidth(root->right)+1;

void TreeWalk(node* root)

if(!root) return ;
TreeWalk(root->left);
cout<<root->value<<' ';
TreeWalk(root->right);


void main()

node* root=CreateTree();
TreeWalk(root);
int TreeHeigh=TreeHeight(root);
cout<<endl<<TreeHeigh<<endl;
int TreeLeave=TreeLeaves(root);
cout<<endl<<TreeLeave<<endl;
int TreeWid=TreeWidth(root);
cout<<endl<<TreeWid<<endl;

二叉树的基本运算

//二叉树的初始化操作。二叉树的初始化须要将指向二叉树的根结点指针置为空：
void InitBitTree(BiTree *T)//二叉树的初始化操作
{
	*T=NULL;
}
//二叉树的销毁操作。
假设二叉树存在。将二叉树存储空间释放：

void DestroyBitTree(BiTree *T)//销毁二叉树操作
{
	if(*T)//假设是非空二叉树
	{
		if((*T)->lchild)
			DestroyBitTree(&((*T)->lchild));
		if((*T)->rchild)
			DestroyBitTree(&((*T)->rchild));
		free(*T);
		*T=NULL;
	}
}
//创建二叉树操作。
依据二叉树的递归定义，先生成二叉树的根结点。将元素值赋给结点的数据域，然后递归创建
//左子树和右子树。当中‘#’表示空：

void CreatBitTree(BiTree *T)//递归创建二叉树
{
	DataType ch;
	scanf("%c",&ch);
	if(ch==‘#‘)
		*T=NULL;
	else
	{
		*T=(BiTree)malloc(sizeof(BitNode));//生成根结点
		if(!(*T))
			exit(-1);
		(*T)->data=ch;
		CreatBitTree(&((*T)->lchild));
		CreatBitTree(&((*T)->rchild));
	}
}
//二叉树的左插入操作。
指针p指向二叉树T的某个结点，将子树c插入到T中，使c成为p指向结点的左子树
//，p指向结点的原来左子树成为c的右子树：


int InsertLeftChild(BiTree p,BiTree c)//二叉树的左插入操作
{
	if(p)//假设指针p不空
	{
		c->rchild=p->lchild;//p的原来的左子树成为c的右子树
		p->lchild=c;//子树c作为p的左子树
		return 1;
	}
	return 0;
}
//二叉树的右插入操作。指针p指向二叉树T的某个结点，将子树c插入到T中，使c成为p指向结点的右子树
//。p指向结点的原来右子树成为c的右子树：

int InsertRightChild(BiTree p,BiTree c)//二叉树的右插入操作
{
	if(p)//假设指针p不空
	{
		c->rchild=p->rchild;//p的原来的右子树成为c的右子树
		p->rchild=c;//子树c作为p的右子树
		return 1;
	}
	return 0;
}
/*返回二叉树结点的指针操作。在二叉树中查找指向元素值为e的结点。假设找到该结点，则将该结点的指针
返回，否则，返回NULL。
详细实现：定义一个队列Q，用来存放二叉树中结点的指针。从根结点開始，推断结点的值是否等于e，假设
相等，则返回该结点的指针；否则，将该结点的左孩子结点的指针和右孩子结点的指针入队列。假设结点存在
左孩子结点，则将其左孩子的指针入队列；假设结点存在右孩子结点，则将其右孩子的指针入队列。然后将
队头的指针出队列。推断该指针指向的结点的元素值是否等于e。假设相等，则返回该结点的指针，否则，继续
将结点的左孩子结点的指针和右孩子结点的指针入队列。
反复此操作，直到队列为空。
*/


BiTree Point(BiTree T,DataType e)//查找元素值为e的结点的指针
{
	BiTree Q[MAXSIZE];//定义一个队列。用于存放二叉树中结点的指针
	int front=0,rear=0;//初始化队列
	BitNode *p;
	if(T)//假设二叉树非空
	{
		Q[rear]=T;
		rear++;
		while(front!=rear)//假设队列非空
		{
			p=Q[front];//取出队头指针
			front++;//将队头指针出队
			if(p->data==e)
				return p;
			if(p->lchild)//假设左孩子结点存在，将左孩子指针入队
			{
				Q[rear]=p->lchild;//左孩子结点的指针入队
				rear++;
			}
            if(p->rchild)//假设右孩子结点存在，将右孩子指针入队
			{
				Q[rear]=p->rchild;//右孩子结点的指针入队
				rear++;
			}
		}
	}
	return NULL;
}  
//返回二叉树的结点的左孩子元素值操作。
假设元素值为e的结点存在。而且该结点的左孩子结点存在，则将
//该结点的左孩子结点的元素值返回。


DataType LeftChild(BiTree T,DataType e)//返回二叉树的左孩子结点元素值操作
{
	BiTree p;
	if(T)//假设二叉树非空
	{
		p=Point(T,e);//p是元素值e的结点的指针
		if(p&&p->lchild)//假设p不为空且p的左孩子结点存在
			return p->lchild->data;
	}
	return;
}
//返回二叉树的结点的右孩子元素值操作。假设元素值为e的结点存在，而且该结点的右孩子结点存在，则将
//该结点的右孩子结点的元素值返回。


DataType RightChild(BiTree T,DataType e)//返回二叉树的右孩子结点元素值操作
{
	BiTree p;
	if(T)//假设二叉树非空
	{
		p=Point(T,e);//p是元素值e的结点的指针
		if(p&&p->rchild)//假设p不为空且p的右孩子结点存在
			return p->rchild->data;
	}
	return;
}
//二叉树的左删除操作。在二叉树中，指针p指向二叉树中的某个结点。将p所指向的结点的左子树删除。假设删除
//成功。返回1。否则返回0.

int DeleteLeftChild(BiTree p)//二叉树的左删除操作
{
	if(p)//假设指针p不空
	{
		DestroyBitTree(&(p->lchild));//删除左子树
		return 1;
	}
	return 0;
}


//二叉树的右删除操作。在二叉树中。指针p指向二叉树中的某个结点，将p所指向的结点的右子树删除。
假设删除
//成功，返回1，否则返回0.
int DeleteRightChild(BiTree p)//二叉树的右删除操作
{
	if(p)//假设指针p不空
	{
		DestroyBitTree(&(p->rchild));//删除右子树
		return 1;
	}
	return 0;
}