第5章课后习题算法设计题（严蔚敏数据结构c语言版第2版）

以二叉链表作为二叉树的存储结构，编写以下算法：
（1）统计二叉树的叶节点个数。
（2）判别两棵树是否相等。
（3）交换二叉树每个结点的左孩子和右孩子。
（6）用按层次顺序遍历二叉树的方法，统计树中度为1的结点数目。
5-1 统计二叉树的叶节点个数

#include <iostream>
typedef struct BiTNode{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreatBiTree(BiTree &T);
void PreOrderTraverse(BiTree T);
void InOrderTraverse(BiTree T);
void PostOrderTraverse(BiTree T);
int LeafCount(BiTree T);
using namespace std;
int main(){
    BiTree T;
    cout<<"先序遍历顺序建立二叉树为："<<endl;
    CreatBiTree(T);
    cout<<"先序遍历输出为:"<<endl;
    PreOrderTraverse(T);
    cout<<endl;
    cout<<"中序遍历输出为:"<<endl;
    InOrderTraverse(T);
    cout<<endl;
    cout<<"后序遍历输出为:"<<endl;
    PostOrderTraverse(T);
    cout<<endl;
    cout<<"该二叉树叶子结点个数为："<<LeafCount(T)<<endl;
    return 0;
}
//先序建立二叉树
void CreatBiTree(BiTree &T){
    char ch;
    cin>>ch;
    if(ch=='#'){
        T=NULL;
    }else if(ch!='#'){
        T=new BiTNode;
        T->data=ch;
        CreatBiTree(T->lchild);
        CreatBiTree(T->rchild);
    }
}
//前序遍历:若结点不为空就输出，遍历左子树，然后遍历右子树；
//         若为空就不输出
void PreOrderTraverse(BiTree T){
    if(T){
        cout<<T->data<<" ";
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}
//中序遍历:若结点不为空就遍历左子树，输出根结点数据，再遍历右子树；
//         若为空就不输出
void InOrderTraverse(BiTree T){
    if(T){
        InOrderTraverse(T->lchild);
        cout<<T->data<<" ";
        InOrderTraverse(T->rchild);
    }
}
//后序遍历:若结点不为空就遍历左子树，然后遍历右子树，输出根结点数据；
//         若为空就不输出
void PostOrderTraverse(BiTree T){
    if(T){
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        cout<<T->data<<" ";
    }
}
//叶子结点个数
int LeafCount(BiTree T){
    if(T==NULL){
        return 0;
    }else if(T->lchild==NULL && T->rchild==NULL){
        return 1;
    }else{
        return LeafCount(T->lchild)+LeafCount(T->rchild);
    }
}

5-2 判别两棵树是否相等

#include <iostream>
typedef struct BiTNode{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void InitBiTree(BiTree &T);
void CreatBiTree(BiTree &T);
void PreOrderTraverse(BiTree T);
bool IsEqual(BiTree T1,BiTree T2);
using namespace std;
int main(){
    BiTree T1,T2;
    cout<<"先序遍历顺序建立二叉树T1为："<<endl;
    CreatBiTree(T1);
    cout<<"T1先序遍历输出为:"<<endl;
    PreOrderTraverse(T1);
    cout<<endl;

    cout<<"先序遍历顺序建立二叉树T2为："<<endl;
    CreatBiTree(T2);
    cout<<"T2先序遍历输出为:"<<endl;
    PreOrderTraverse(T2);
    cout<<endl;
    if(IsEqual(T1,T2)){
        cout<<"T1和T2相等"<<endl;
    }else if(!IsEqual(T1,T2)){
        cout<<"T1和T2不相等"<<endl;
    }
}
void InitBiTree(BiTree &T){
}
//先序建立二叉树
void CreatBiTree(BiTree &T){
    char ch;
    cin>>ch;
    if(ch=='#'){
        T=NULL;
    }else if(ch!='#' && ch!='!'){
        T=new BiTNode;
        T->data=ch;
        CreatBiTree(T->lchild);
        CreatBiTree(T->rchild);
    }
}
//先序遍历:若结点不为空就输出，遍历左子树，然后遍历右子树；
//         若为空就不输出
void PreOrderTraverse(BiTree T){
    if(T){
        cout<<T->data<<" ";
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}
//两棵树是否相等
bool IsEqual(BiTree T1,BiTree T2){
    if((T1==NULL) && (T1==NULL)){//根结点都为空相等
        return true;
    }else if((T1==NULL)!=(T1==NULL)){//根结点一个为空，
                                    //一个不为空不相等
        return false;
    }else if(T1->data!=T2->data){//根结点数据不等就不相等
        return false;
    }
    //结点不空有数据
    return (IsEqual(T1->lchild,T2->lchild)
            && IsEqual(T1->rchild,T2->rchild));
}

5-3 交换二叉树每个结点的左孩子和右孩子

#include <iostream>
typedef struct BiTNode{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void InitBiTree(BiTree &T);
void CreatBiTree(BiTree &T);
void PreOrderTraverse(BiTree T);
void Exchange(BiTree &T);
using namespace std;
int main(){
    BiTree T;
    cout<<"先序遍历顺序建立二叉树为："<<endl;
    CreatBiTree(T);
    cout<<"先序遍历输出为:"<<endl;
    PreOrderTraverse(T);
    cout<<endl;
    Exchange(T);
    cout<<"交换后先序遍历顺序输出为:"<<endl;
    PreOrderTraverse(T);
}
void InitBiTree(BiTree &T){
}
//先序建立二叉树
void CreatBiTree(BiTree &T){
    char ch;
    cin>>ch;
    if(ch=='#'){
        T=NULL;
    }else if(ch!='#' && ch!='!'){
        T=new BiTNode;
        T->data=ch;
        CreatBiTree(T->lchild);
        CreatBiTree(T->rchild);
    }
}
//先序遍历:若结点不为空就输出，遍历左子树，然后遍历右子树；
//         若为空就不输出
void PreOrderTraverse(BiTree T){
    if(T){
        cout<<T->data<<" ";
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}
//交换每个结点的左右子树:叶子结点不用交换，不是叶子结点就交换，交换左子树和右子树
void Exchange(BiTree &T){
    if(T){
        if(T->lchild==NULL && T->rchild==NULL){
            return;
        }else{
            BiTree temp;
            temp=T->lchild;
            T->lchild=T->rchild;
            T->rchild=temp;
        }
        Exchange(T->lchild);
        Exchange(T->rchild);
    }
}

5-6 用按层次顺序遍历二叉树的方法，统计树中度为1的结点数目

#include <iostream>
#define m 100
typedef struct BiTNode{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
typedef struct{
    BiTree base;
    int front;
    int rear;
}SqQueue;
void InitBiTree(BiTree &T);
void CreatBiTree(BiTree &T);
void PreOrderTraverse(BiTree T);
int OneCount(BiTree T);
void InitQueue(SqQueue &s);
void EnQueue(SqQueue &s,BiTree T);
BiTree DeQueue(SqQueue &s);
bool IsEmpty(SqQueue s);
using namespace std;
int main(){
    BiTree T;
    cout<<"先序遍历顺序建立二叉树为："<<endl;
    CreatBiTree(T);
    cout<<"先序遍历输出为:"<<endl;
    PreOrderTraverse(T);
    cout<<endl;
    cout<<"该二叉树度为1的结点个数为："<<OneCount(T)<<endl;
}
void InitBiTree(BiTree &T){
}
//先序建立二叉树
void CreatBiTree(BiTree &T){
    char ch;
    cin>>ch;
    if(ch=='#'){
        T=NULL;
    }else if(ch!='#' && ch!='!'){
        T=new BiTNode;
        T->data=ch;
        CreatBiTree(T->lchild);
        CreatBiTree(T->rchild);
    }
}
void PreOrderTraverse(BiTree T){
    if(T){
        cout<<T->data<<" ";
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}
//层次顺序遍历:先进先出符合队列，先让第一层结点入队，然后依次入队；
//             依次出队就为层次顺序遍历
//度为1的结点个数
int sum=0;
int OneCount(BiTree T){
    SqQueue s;
    if(T){
        InitQueue(s);
        EnQueue(s,T);
        while(!IsEmpty(s)){
            BiTree temp;
            temp=DeQueue(s);
            if((temp->lchild && !temp->rchild) ||
               (!temp->lchild && temp->rchild)){
                sum++;
            }
            if(temp->lchild){
                EnQueue(s,temp->lchild);
            }
            if(temp->rchild){
                EnQueue(s,temp->rchild);
            }
        }
    }
    return sum;
}
void EnQueue(SqQueue &s,BiTree e){
    if(s.front==(s.rear+1)%m){
        cout<<"队列满了无法入队"<<endl;
    }else{
        s.base[s.rear]=*e;
        s.rear=(s.rear+1)%m;
    }
}
BiTree DeQueue(SqQueue &s){
    BiTree e;
    if(s.front==s.rear){
//        cout<<"队列空了无法出队"<<endl;
        return NULL;
    }else{
        *e=s.base[s.front];
        s.front=(s.front+1)%m;
        return e;
    }
}
//初始化循环队列
void InitQueue(SqQueue &s){
    s.base=new BiTNode[m];
    s.front=s.rear=0;
}
bool IsEmpty(SqQueue s){
    if(s.front==s.rear){
        return true;
    }else{
        return false;
    }
}