【数据结构 严蔚敏版】 二叉树 基本操作
计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。
一棵深度为k，且有2^k-1个节点的二叉树，称为满二叉树。这种树的特点是每一层上的节点数都是最大节点数。而在一棵二叉树中，除最后一层外，若其余层都是满的，并且最后一层或者是满的，或者是在右边缺少连续若干节点，则此二叉树为完全二叉树。具有n个节点的完全二叉树的深度为floor(log2n)+1。深度为k的完全二叉树，至少有2k-1个叶子节点，至多有2k-1个节点。
#include
#include
#include
#define Maxsize 10//最大量
using namespace std;
typedef int Status ;
typedef char QElemType;
typedef char TElemType;
//树节点
typedef struct BiTNode{
TElemType data;
struct BiTNode *lchild;
struct BiTNode *rchild;
}BiTNode,*BiTree;
//定义队列节点
typedef struct QNode{
BiTNode *data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
QueuePtr front;
QueuePtr rear;
}LinkQueue;
//建立队列
Status InitQueue(LinkQueue &Q){
Q.front =(QueuePtr)malloc(sizeof(QNode));
if(!Q.front)
{
cout<<"内存分配失败，程序退出！！！"<next =NULL;
return 1;
}
//入队
Status EnQueue (LinkQueue &Q,BiTree &T){
QueuePtr p;
p = (QueuePtr)malloc(sizeof(QNode));
if(!p){
cout<<"内存分配失败，程序退出！！！"<data = T;
p->next = NULL;
Q.rear->next = p;
Q.rear = p;
return 1;
}
//判空
Status QueueEmpty(LinkQueue Q){
if(Q.front ==Q.rear){
return 0;
}
else
return 1;
}
//元素出队列
Status DeQueue(LinkQueue &Q,BiTree &T){
QueuePtr p;
if(Q.front == Q.rear){
return 0;
}
p = Q.front->next;
T = p->data;
Q.front->next = p->next;
if(Q.rear == p)
Q.rear = Q.front;
free(p);
return 1;
}
//遍历队列元素
Status QueueTraverse(LinkQueue Q){
int i;
if(Q.front ==Q.rear){
return 0;
}
for(i=0;Q.front !=Q.rear;i++){
Q.front = Q.front->next;
cout<data<<" ";
}
cout<data = ch;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
return 1;
}
//销毁二叉树
Status Destory_Bitree(BiTree &T)
{
if(T)
{
if(T->lchild)
Destory_Bitree(T->lchild);
if(T->rchild)
Destory_Bitree(T->rchild);
free(T);
T=NULL;
}
return 1;
}
//清空二叉树
Status Clear_Bitree(BiTree &T)
{
if(T==NULL)
{
return 1;
}
Clear_Bitree(T->lchild);
Clear_Bitree(T->rchild);
free(T);
}
//先序遍历
void PreOrderTraverse(BiTree T){
if(T){
cout<data<<" ";
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}
//中序遍历
void InOrderTraverse(BiTree T){
if(T){
InOrderTraverse(T->lchild);
cout<data<<" ";
InOrderTraverse(T->rchild);
}
}
//后序遍历
void PostOrderTraverse(BiTree T){
if(T){
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
cout<data<<" ";
}
}
//层序遍历
void levelOrderTraverse(BiTree T){
LinkQueue Q;
InitQueue(Q);
EnQueue(Q,T);
BiTree p ;
while(QueueEmpty(Q)){
DeQueue(Q,p);
cout<data<<" ";
if(p->lchild)
EnQueue(Q,p->lchild);
if(p->rchild)
EnQueue(Q,p->rchild);
}
cout<lchild && !tag)
EnQueue(Q,p->lchild);
else{
if(p->lchild)
return 0;
else
tag = 1;
}
if(p->rchild && !tag)
EnQueue(Q,p->rchild);
else{
if(p->lchild)
return 0;
else
tag = 1;
}
}
return 1;
}
//二叉树的深度
Status Depth_Bitree(BiTree T)
{
int hl=0,hr=0;
if(T==NULL) return 0;
else
{
hl=Depth_Bitree(T->lchild);
hr=Depth_Bitree(T->rchild);//递归，先左后右
return max(hl,hr)+1;
}
}
//树叶
int Leaves_Bitree(BiTree T)
{
if(T==NULL) return 0;
if(T->lchild==NULL&&T->rchild==NULL)
return 1;
else return Leaves_Bitree(T->lchild)+Leaves_Bitree(T->rchild);
}
void Menu()
{
cout<<" 二叉树基本操作 "< 比较全的基本操作
#include
#include
#include
#define OK 1
#define False 0
#define ll long long
using namespace std;
typedef int Status ;
typedef int Datatype;
typedef struct node
{
Datatype data;//数据
struct node *lchild,*rchild;//指向左右孩子的指针
}BitNode,*Bitree; //Bitree是node结构指针的别名，代表指向BitNode结构体类型的指针
//初始化，构造空二叉树
Status Init_Bitree(Bitree &T)
{
T=NULL;
return OK;
}
//销毁二叉树
Status Destory_Bitree(Bitree &T)
{
if(T)
{
if(T->lchild)
Destory_Bitree(T->lchild);
if(T->rchild)
Destory_Bitree(T->rchild);
free(T);
T=NULL;
}
return OK;
}
//创建二叉树
void Create_Bitree(Bitree &T)
{
char ch;
cin>>ch;
if(ch==' ') T=NULL;
else
{
T=(BitNode*)malloc(sizeof(BitNode));
T->data=ch;
Create_Bitree(T->lchild);
Create_Bitree(T->rchild);
}
}
//清空二叉树
Status Clear_Bitree(Bitree &T)
{
if(T==NULL)
{
return OK;
}
Clear_Bitree(T->lchild);
Clear_Bitree(T->rchild);
free(T);
}
//判断二叉树是否为空
Status Empty_Bitree(Bitree &T)
{
if(T==NULL) return OK;
else return False;
}
//二叉树的深度
Status Depth_Bitree(Bitree T)
{
int hl=0,hr=0;
if(T==NULL) return 0;
else
{
hl=Depth_Bitree(T->lchild);
hr=Depth_Bitree(T->rchild);//递归，先左后右
return max(hl,hr)+1;
}
}
//Root_ 返回T的根
Datatype Root_Bitree(Bitree T)
{
if(T==NULL) return 0;
else return T->data;
}
//返回某个结点的值
Datatype Value_Bitree(Bitree p)
{
return p->data;
}
//结点总数
int Count_Bitree(Bitree T)
{
if(T)
{
return Count_Bitree(T->lchild)+Count_Bitree(T->rchild)+1;
}else return 0;
}
//叶子结点
int Leaves_Bitree(Bitree T)
{
if(T==NULL) return 0;
if(T->lchild==NULL&&T->rchild==NULL)
return 1;
else return Leaves_Bitree(T->lchild)+Leaves_Bitree(T->rchild);
}
//返回节点的双亲
Datatype Parent_Bitree(Bitree T,Datatype e)
{
if(T)
{
queue q;
while(!q.empty()) q.pop();//清空
q.push(T);//根 入队
while(!q.empty())
{
Bitree temp=q.front();//取出队首
q.pop();
if((temp->lchild&&temp->lchild->data==e)||(temp->rchild&&temp->rchild->data==e))
return temp->data;
else
{
if(temp->lchild)
q.push(temp->lchild);
if(temp->rchild)
q.push(temp->rchild);
}
}
}
return False;
}
//返回某个值在数中的节点的指针
Bitree NodePoint_Bitree(Bitree T,Datatype e)
{
if(T==NULL) return False;
Bitree P;
queue q;
while(!q.empty()) q.pop();
P=T;
q.push(P);
while(!q.empty())
{
Bitree temp=q.front();
q.pop();
if(temp->data==e) return temp;
if(temp->lchild) q.push(temp->lchild);
if(temp->rchild) q.push(temp->rchild);
}
return False;//说明没找到
}
//左孩子
Datatype LeftChild_Bitree(Bitree p)
{
if(p->lchild)
{
return p->lchild->data;
}
else return False;
}
//右孩子
Datatype RightChild_Bitree(Bitree p)
{
if(p->rchild)
{
return p->rchild->data;
}
else return False;
}
//左兄弟
Datatype LeftSibing_Bitree(Bitree T,Datatype e)
{
Bitree P;
Init_Bitree(P);
if(T)
{
P=NodePoint_Bitree(T,Parent_Bitree(T,e));
if(P->lchild&&P->rchild&&P->rchild->data==e)
return P->lchild->data;
}else return False;
}
//右兄弟
Datatype RightSibing_Bitree(Bitree T,Datatype e)
{
Bitree P;
Init_Bitree(P);
if(T)
{
P=NodePoint_Bitree(T,Parent_Bitree(T,e));
if(P->lchild&&P->rchild&&P->lchild->data==e)
return P->rchild->data;
}else return False;
}
//结点赋值
void Assign_Bitree(Bitree p,Datatype value)
{
p->data=value;
}
//先序遍历
void PreOrderTraverse(Bitree T,int level)
{
if(T)
{
cout<data<<" "<lchild,level+1);//先遍历左子树
PreOrderTraverse(T->rchild,level+1);//最后再遍历右子树
}
}
//中序遍历
void InOrderTraverse(Bitree T,int level)
{
if(T)
{
InOrderTraverse(T->lchild,level+1);//先遍历左子树
cout<data<<" "<rchild,level+1);//最后遍历右子树
}
}
//后序遍历
void PostOrderTraverse(Bitree T,int level)
{
if(T)
{
PostOrderTraverse(T->lchild,level+1);//先访问左子树
PostOrderTraverse(T->rchild,level+1);//再访问右子树
cout<data<<" "<lchild)
{
Destory_Bitree(P->lchild);
return OK;
}
}else if(LR==1)
{
if(P->rchild)
{
Destory_Bitree(P->rchild);
return OK;
}
}return False;
}
//插入子树
Status InsertChild_Bitree(Bitree P,int LR,Bitree c)
{
if(P)
{
if(LR==0)
{
c->rchild=P->lchild;
P->lchild=c;
}else if(LR==1)
{
c->rchild=P->rchild;
P->rchild=c;
}
return OK;
}else return False;
}
void Menu()
{
cout<<" 二叉树基本操作 "<>option;
switch(option)
{
case 1://创建
cout<<"创建二叉树：";
Create_Bitree(Tree);
cout<<"创建成功"<>e;
Bitree p;
Init_Bitree(p);
p=NodePoint_Bitree(Tree,e);
if(LeftChild_Bitree(p))
{
cout<<"左子树："<>val;
if(LeftSibing_Bitree(Tree,val))
{
cout<<"左兄弟："<>c;
if(Parent_Bitree(Tree,c))
{
cout<