二叉树习题解析-优快云博客

本文链接：https://blog.youkuaiyun.com/Cyril_JZ/article/details/53113095
二叉树习题 3.5

设一棵二叉树以二叉链表表示，试编写有关二叉树的递归算法：
1）统计二叉树中度为1的结点个数；
2）统计二叉树中度为2的结点个数；
3）统计二叉树中度为0（叶节点）的结点个数；
4）统计二叉树的高度；
5）统计二叉树的宽度，即在二叉树的各层上具有结点数最多的那一层上结点总数；
6）计算二叉树中各结点中最大元素的值；
7）交换每个结点的左孩子结点和右孩子结点；
8）从二叉树中删去所有叶节点；
编写算法判别给定二叉树是否为完全二叉树。
//
//  main.cpp
//  3.5
//
//  Created by Cyril on 2016/11/9.
//  Copyright © 2016年 Cyril. All rights reserved.
//

#include <iostream>
#include <queue>
#define MIN -100000000
using namespace std;
//二叉树结点的定义
template <class T>
class BT;

template <class T>
class BTNode
{
    friend class BT<T>;
private:
    T data;
    BTNode *lChild;
    BTNode *rChild;
public:
    BTNode();
    BTNode(T& d);//给定数据域的值得构造函数
    BTNode(T& d, BTNode *l, BTNode *r);//给定数据域以及左右孩子的构造函数
    BTNode<T> *GetLChild();//返回左孩子结点的指针
    BTNode<T> *GetRChild();//返回右孩子结点的指针
    void SetLChild(BTNode<T> *l);//设置左孩子结点
    void SetRChild(BTNode<T> *r);//设置右孩子结点
    ~BTNode(){}
    T GetValue();//返回该节点数据值
    bool SetValue(T& val);//设置该点数据值
    bool IsLeaf();//判断是否为叶子结点
    void DisplayNode();//输出结点
};
template <class T>
BTNode<T>::BTNode()
{
    lChild=rChild=NULL;
}
template <class T>
BTNode<T>::BTNode(T& d)//给定数据域的值得构造函数
{
    lChild=rChild=NULL;
    data=d;
}
template <class T>
BTNode<T>::BTNode(T& d, BTNode *l, BTNode *r)//给定数据域以及左右孩子的构造函数
{
    lChild=l;
    rChild=r;
    data=d;
}
template <class T>
BTNode<T>* BTNode<T>:: GetLChild()//返回左孩子结点的指针
{
    return lChild;
}
template <class T>
BTNode<T>* BTNode<T>:: GetRChild()//返回右孩子结点的指针
{
    return rChild;
}
template <class T>
void BTNode<T>:: SetLChild(BTNode<T> *l)//设置左孩子结点
{
    lChild=l;
}
template <class T>
void BTNode<T>:: SetRChild(BTNode<T> *r)//设置右孩子结点
{
    rChild=r;
}
template <class T>
T BTNode<T>:: GetValue()//返回该节点数据值
{
    return data;
}
template <class T>
bool BTNode<T>:: SetValue(T& val)//设置该点数据值
{
    this->data=val;
    return true;
}
template <class T>
bool BTNode<T>:: IsLeaf()//判断是否为叶子结点
{
    if(lChild==NULL&&rChild==NULL)
        return true;
    else
        return false;
}
template <class T>
void BTNode<T>:: DisplayNode()//输出结点
{
    cout<<"该结点的数据为: "<<data<<endl;
}
//二叉树类的定义
template <class T>
class BT
{
private:
    BTNode<T> *root;//二叉树的根节点
    int s;//用于记录结点的个数
public:
    BT(){root=NULL;}
    ~BT(){}
    void NewTree();//创建新树
    BTNode<T>* SetSubTree();//创建子树并返回子树的根结点地址
    bool IsEmpty();//判断是否为空树
    BTNode<T>* GetRoot();//返回根节点
    bool GetParent(BTNode<T> *cur);//返回当前结点的父节点.（未实现）
    bool GetLSibling(BTNode<T> *cur);//返回当前结点的左兄弟.（未实现）
    bool GetRSibling(BTNode<T> *cur);//返回当前结点的右兄弟.（未实现）
    bool LevelOrder(BTNode<T> *r);//广度优先遍历
    bool PreOrder(BTNode<T> *r);//前序遍历
    bool DeleteNode(BTNode<T> *r);//删除以r为根结点的子树.（未实现）
    void Display();//输出树
    void RecDisplay(BTNode<T> *t);//用于输出树时的循环迭代

    int GetDegree(int num);//计算二叉树中度为num的结点个数,并返回
    int CalDegree2(BTNode<T> *r);//计算结点为2的结点个数，并返回
    int CalDegree1(BTNode<T> *r);//计算结点为1的结点个数，并返回
    int CalDegree0(BTNode<T> *r);//计算结点为0的结点个数，并返回

    int GetHeight(BTNode<T> *r);//计算二叉树的高度，并返回
    void CalWidth(BTNode<T> *r,int *count,int depth);//递归计算二叉树的宽度
    int GetWidth();//计算二叉树宽度

    T GetMax(BTNode<T> *r);//计算二叉树中结点的最大元素，并返回
    void SwapChildren(BTNode<T> *r);//交换每一个结点的左孩子结点和右孩子结点
    void DeleteLeaf(BTNode<T> *r);//删除叶节点

    bool IsCompleteBT();//判断是否为完全二叉树
};
template <class T>
void BT<T>::NewTree()//创建新树
{
    cout<<"请输入根结点的数据："<<endl;
    root=SetSubTree();
}
template <class T>
BTNode<T>* BT<T>::GetRoot()//返回根节点
{
    return root;
}
template <class T>
BTNode<T>* BT<T>:: SetSubTree()//创建子树并返回子树的根结点地址
{
    T t;
    cin>>t;
    BTNode<T> *p;
    if(t=='#')
        return NULL;//返回空指针
    else
    {
        p=new BTNode<T>;
        p->SetValue(t);
        //cout<<"成功读入"<<t<<endl;
        cout<<"请输入左孩子结点的数据：（输入‘#’则表示不存在左孩子结点）"<<endl;
        p->SetLChild(SetSubTree());
        cout<<"请输入右孩子结点的数据：（输入‘#’则表示不存在右孩子结点）"<<endl;
        p->SetRChild(SetSubTree());
        return p;
    }
}
template <class T>
bool BT<T>:: IsEmpty()//判断是否为空树
{
    return !root;
}
template <class T>
bool BT<T>:: LevelOrder(BTNode<T> *r)//广度优先遍历
{
    queue<BTNode<T>*> NodeQueue;
    BTNode<T> *p=root;
    if(p)
        NodeQueue.push(p);
    while (!NodeQueue.empty())
    {
        p=NodeQueue.front();
        //...访问p指针指向的结点
        //样例操作：广度优先输出树 cout<<p->data<<' ';
        NodeQueue.pop();
        if(p->lChild)
            NodeQueue.push(p->lChild);
        if(p->rChild)
            NodeQueue.push(p->rChild);
    }
    return true;
}
template <class T>
bool BT<T>:: PreOrder(BTNode<T> *r)//前序遍历
{
    if(r)
    {
        //...访问r指针指向的结点
        //样例操作：深度优先输出树 cout<<r->data<<' ';
        PreOrder(r->lChild);
        PreOrder(r->rChild);
        return true;
    }
    return false;
}
template <class T>
void BT<T>:: Display()
{
    RecDisplay(root);
    cout<<endl;
}
template <class T>
void BT<T>:: RecDisplay(BTNode<T> *t)
{
    if(t!=NULL)
    {
        cout<<t->data;
        if(t->lChild||t->rChild)
        {
            cout<<'(';
            RecDisplay(t->lChild);
            cout<<',';
            if(t->rChild)
                RecDisplay(t->rChild);
            else
                cout<<'#';
            cout<<')';
        }
    }
    else
    {
        cout<<'#';
    }
}

template <class T>
int BT<T>:: GetDegree(int num)//计算二叉树中度为num的结点个数,并返回
{
    s=0;
    if(num==2)
        return CalDegree2(root);
    else if(num==1)
        return CalDegree1(root);
    else if(num==0)
        return CalDegree0(root);
    else
        return -1;//不合法就返回-1
}
template <class T>
int BT<T>:: CalDegree2(BTNode<T> *r)//计算结点为2的结点个数，并返回
{
    if(!r)
        return 0;//空指针返回0
    s=(r->lChild!=NULL)&&(r->rChild!=NULL);
    return s+CalDegree2(r->lChild)+CalDegree2(r->rChild);
}
template <class T>
int BT<T>:: CalDegree1(BTNode<T> *r)//计算结点为1的结点个数，并返回
{
    if(!r)
        return 0;//空指针返回0
    s=(r->lChild!=NULL&&r->rChild==NULL)||(r->lChild==NULL&&r->rChild!=NULL);//异或算法
    return s+CalDegree1(r->lChild)+CalDegree1(r->rChild);
}
template <class T>
int BT<T>:: CalDegree0(BTNode<T> *r)//计算结点为0的结点个数，并返回
{
    if(r==NULL)
        return 0;//空指针返回1
    s=(r->lChild==NULL)&&(r->rChild==NULL);
    return s+CalDegree0(r->lChild)+CalDegree0(r->rChild);
}

template <class T>
int BT<T>:: GetHeight(BTNode<T> *r)//计算二叉树的高度，并返回
{
    if(!r)
        return 0;
    int left=GetHeight(r->lChild)+1;
    int right=GetHeight(r->rChild)+1;
    return (left>right)?left:right;
}
template <class T>
void BT<T>:: CalWidth(BTNode<T> *r,int *count,int depth)//递归计算二叉树的宽度
{
    if(!r)
        return ;
    count[depth]++;
    CalWidth(r->lChild,count,depth+1);
    CalWidth(r->rChild,count,depth+1);
}
template <class T>
int BT<T>:: GetWidth()
{
    int de=GetHeight(root);
    int *count=new int [de];
    for(int i=0;i<de;i++)
        count[i]=0;
    CalWidth(root,count,0);
    int max=0;
    for(int i=0;i<de;i++)
        max=((count[i]>max)?count[i]:max);
    return max;
}
template <class T>
T BT<T>:: GetMax(BTNode<T> *r)//计算二叉树中结点的最大元素，并返回
{
   // cout<<r<<endl;
    if(r)
    {
        T left=GetMax(r->lChild);
        T current=r->data;
        T right=GetMax(r->rChild);
        T max=((left>right)?left:right);
        return ((current>max)?current:max);
    }
    else
        return MIN;
}
template <class T>
void BT<T>::SwapChildren(BTNode<T> *r)//交换每一个结点的左孩子结点和右孩子结点
{
    if(!r)
        return;
    BTNode<T> *temp;
    temp=r->lChild;
    r->lChild=r->rChild;
    r->rChild=temp;
    SwapChildren(r->lChild);
    SwapChildren(r->rChild);
}
template <class T>
void BT<T>:: DeleteLeaf(BTNode<T> *r)//删除叶节点
{
    if(!r)
        return;
    if(!root->lChild&&!root->rChild)
    {
        delete root;
        root=NULL;
    }
    if(r->lChild)
    {
        if(!r->lChild->lChild&&!r->lChild->rChild)
        {
            delete r->lChild;
            r->lChild=NULL;
        }
        else
            DeleteLeaf(r->lChild);
    }
    if(r->rChild)
    {
        if(!r->rChild->lChild&&!r->rChild->rChild)
        {
            delete r->rChild;
            r->rChild=NULL;
        }
        else
            DeleteLeaf(r->rChild);
    }
}
template <class T>
bool BT<T>:: IsCompleteBT()//判断是否为完全二叉树
{
    queue<BTNode<T>*> NodeQueue;
    int flag=1;
    NodeQueue.push(root);
    while(!NodeQueue.empty())
    {
        BTNode<T> *p=NodeQueue.front();
        NodeQueue.pop();
        if(p)
        {
            if(!flag) return false;
            NodeQueue.push(p->lChild);
            NodeQueue.push(p->rChild);
        }
        else
        {
            flag=0;
        }
    }
    return true;
}
int main()
{
    BT<char> Tree;
    Tree.NewTree();
    cout<<"该二叉树为"<<endl;
    Tree.Display();
    if(Tree.IsCompleteBT())
        cout<<"该二叉树为完全二叉树"<<endl;
    else
        cout<<"该二叉树不是完全二叉树"<<endl;
    for(int i=0;i<3;i++)
    {
        cout<<"二叉树中度为"<<i<<"的结点个数为："<<Tree.GetDegree(i)<<endl;
    }
    cout<<"二叉树的高度为："<<Tree.GetHeight(Tree.GetRoot())<<endl;
    cout<<"二叉树的宽度为："<<Tree.GetWidth()<<endl;
    cout<<"二叉树的最大元素为："<<Tree.GetMax(Tree.GetRoot())<<endl;
    cout<<"交换每一个左右孩子后的二叉树为："<<endl;
    Tree.SwapChildren(Tree.GetRoot());
    Tree.Display();
    cout<<"删除叶节点后的二叉树为："<<endl;
    Tree.DeleteLeaf(Tree.GetRoot());
    Tree.Display();
    return 0;
}