递归统计二叉树度为1/2/3/高度/宽度/删去所有叶结点/指定P所在的层次/最大元素的值/交换每个结点的左右子女/先序输出全部结点的数据值和结点所在的层次

测试数据：ADF##E##MN###

主代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include
// using namespace std;

#define maxsize 100
#define ElemType char

//二叉树存储
typedef struct BiNode {
ElemType data;
struct BiNode *lchild ;
struct BiNode *rchild ;
}BiNode ,*BiTree;
int main() {
BiTree T;

// 先序输入二叉树的顺序 
CreateBiTree(T);

// 递归求二叉树中结点为1的度
// int oneNum = OneDgree(T);
// printf("%d",oneNum);
// printf("\n");

// int twoNum = twoDgree (T);
// printf("%d",twoNum);
// printf("\n");
// int zeroNum = zeroDgree(T);
// printf("%d",zeroNum);

// 先序递归输出二叉树结点
//PreOrder(T);

// 找出二叉树先序遍历的第K 个结点并输出值

// int k = 5;

//ElemType ch = search_K_pre_order(T,k);
//printf("%c",ch);
//InOrder (T);

// PostOrder(T);

// int BinaryWidth = BinaryTreeMaxWidth(T,1);
// printf("width \n");
// printf("%d",BinaryWidth);

// deleteLeaf(T);
// printf("height \n");
// int BinHeight = BinaryHeight(T);
// printf("%d",BinHeight);
// printf("\n");
//LevelOrder(T);
// BiNode *p ;
// p->data = 'F';
// p->rchild = NULL;
// p->lchild = NULL;
// int level = getLevel(T);
// printf("level \n");
// printf("%d",level);

// char max_data = treeMaxData(T);
// printf("maxData \n");
//  printf("%c",max_data);
//  SwapChild(T);
// LevelOrder(T);
preOrderOutPut(T,1);

return 0;

}
建树：
void CreateBiTree(BiTree &T) {
ElemType ch;
scanf(“%c”,&ch);
// ch = getchar();

if(ch == ‘#’) {
T = NULL;
}
else {
T = (BiNode *)malloc(sizeof(BiNode));
T->data = ch;
// T->lchild = NULL;
// T->rchild = NULL;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
};
// 统计二叉树中度为1的结点个数

int OneDgree(BiTree T) {
if(T==NULL ){
return 0;
}
if( (T->lchild == NULL && T->rchild !=NULL ) || (T->lchild != NULL && T->rchild ==NULL)) {
return 1 + OneDgree(T->rchild) + OneDgree(T->lchild);
}

else {
    return OneDgree(T->lchild) +OneDgree(T->rchild);
}

};
// 统计二叉树中结点度为2的结点个数
int twoDgree(BiTree T) {
if(T == NULL) {
return 0;
}
if(T->lchild!=NULL && T->rchild !=NULL) {
return twoDgree(T->lchild) +twoDgree (T->rchild) +1;
}
else {
return twoDgree(T->lchild) +twoDgree(T->rchild);
}
};

// 统计二叉树中度为0的结点个数
int count0 = 0;
int zeroDgree(BiTree T) {
if(T == NULL) {
return 0;
}
if(T->lchild == NULL && T->rchild ==NULL) {
return count0 + 1;
}
else {
return zeroDgree(T->lchild) +zeroDgree(T->rchild);
}
};
先序序列输出树/中序/后序
void PreOrder (BiTree T) {

if(T) 
{
    printf("%c",T->data);
    PreOrder(T->lchild);
    PreOrder(T->rchild);
}

};

void InOrder (BiTree T) {

if(T) 
{
   
    InOrder(T->lchild);
    printf("%c",T->data);
    InOrder(T->rchild);
}

};

void PostOrder (BiTree T) {

if(T) 
{
   
    InOrder(T->lchild);
    
    InOrder(T->rchild);

    printf("%c",T->data);
}

};
// 递归输出二叉树前序序列中的第Ｋ个结点的值
int num_K_start = 1;
ElemType search_K_pre_order(BiTree T,int k){
if(T == NULL) {
return ‘#’;
}
if(num_K_start == k) {
// printf(“%c”,T->data);
return T->data;
}
num_K_start ++;
ElemType ch = search_K_pre_order(T->lchild,k);
if(ch) {
return ch;
}
ch = search_K_pre_order(T->rchild,k);
return ch;
};

//输出二叉树中最大的结点值
char Temp = ‘A’;
ElemType treeMaxData(BiTree T) {
if(T) {

    char lData = treeMaxData(T->lchild);
     lData > Temp ? Temp = lData :Temp;
    char rData = treeMaxData(T->rchild);
     rData > Temp ? Temp = rData :Temp;
    T->data > Temp ? Temp = T->data : Temp;
    
}
return Temp;

};

// 交换二叉树中左右两个子女
void SwapChild(BiTree &T) {
if(T) {
SwapChild(T->lchild);
SwapChild(T->rchild);
BiNode *TempCh = T->lchild;
T->lchild = T->rchild;
T->rchild = TempCh;

}
};

//
先序输出结点及每个结点所在的层次
void preOrderOutPut(BiTree T,int LevelNode) {
if(T==NULL) {
return;
}
printf(“%c”,T->data);
printf(" “);
printf(”%d",LevelNode);
printf(" ");
if(T->lchild) preOrderOutPut(T->lchild,LevelNode+1);
if(T->rchild) preOrderOutPut(T->rchild,LevelNode+1);

};

// 递归统计二叉树的宽度

int countWidths[maxsize];
int currentMax = -1;

int BinaryTreeMaxWidth (BiTree T,int k) {
if(T == NULL ) {
return 0;
}
countWidths[k] ++;
if(currentMax < countWidths[k]) {
currentMax = countWidths[k];
}
BinaryTreeMaxWidth(T->lchild,k+1);
BinaryTreeMaxWidth (T->rchild,k+1);
return currentMax;
};
//递归删除二叉树中的叶结点
void deleteLeaf(BiTree T) {
BiNode *p = T;
if( (p->lchild==NULL &&p->rchild NULL ) || pNULL) {
free§;
return;
}
if(p->lchild){
if(p->lchild->lchild || p->lchild->rchild) {
deleteLeaf(p->lchild);

    }
    else {
        free(p->lchild);
        p->lchild = NULL;
    }
}
 if(p->rchild ) {
    if(p->rchild->lchild || p->rchild->rchild) {
       deleteLeaf(p->rchild);
    }
    else {
        free(p->rchild);
        p->rchild = NULL;
    }
}

};
// 输出指定结点所在的层次

int getLevel(BiTree T) {
if(T==NULL) {
return 0;
}
else {
if(T->data == ‘F’){
return 1;
}
int L = getLevel(T->lchild);
int r = getLevel(T->rchild);
if(L||r) {
return 1+(L>r?L:r);
}else {
return 0;
}
}
};

// 统计二叉树的高度
int lHeight = 0;
int rHeight = 0;
int BinaryHeight(BiTree T) {
if(T ==NULL) {
return 0;
}

lHeight =  1 + BinaryHeight(T->lchild);


rHeight = 1+BinaryHeight (T->rchild);
return (lHeight > rHeight ? lHeight :rHeight );

};