二叉树部分递归运算

设一棵二叉树以二叉链表表示，试编写有关二叉树的递归算法
（1）统计二叉树中度为1的节点个数
（2）统计二叉树中度为2的节点个数
（3）统计二叉树中度为0的节点（叶节点）个数
（4）统计二叉树的高度
（5）统计二叉树的宽度，即在二叉树的各层上具有结点数最多的那一层上结点总数
（6）计算二叉树中各节点中的最大元素值
（7）交换每个结点的左孩子结点和右孩子结点
（8）从二叉树中删去所有叶子结点

代码如下

#include <iostream>
#include "queue"
using namespace std;

class BinaryTreeNode
{
public:
int element;
BinaryTreeNode * lc;
BinaryTreeNode * rc;
BinaryTreeNode(int E){element=E;lc=rc=NULL;}
};

class BinaryTree
{
private:
BinaryTreeNode * root;
public:
BinaryTree(){root=NULL;}
BinaryTreeNode * Create(BinaryTreeNode *);
BinaryTreeNode * GiveRoot();
int Degrees0(BinaryTreeNode *);//度为0的结点个数
int Degrees1(BinaryTreeNode *);//度为1的结点个数
int Degrees2(BinaryTreeNode *);//度为2的结点个数
int Height(BinaryTreeNode * );//高度
int Width(BinaryTreeNode * , queue<BinaryTreeNode *>);//宽度
int Max(BinaryTreeNode *);//求出节点中最大的数据
void Swap(BinaryTreeNode *);//交换左右儿结点
void Delete(BinaryTreeNode *);//删除叶子
void Show();//遍历显示
};
int BinaryTree::Width(BinaryTreeNode * p,queue<BinaryTreeNode *> Q)
{
int n=0;
queue<BinaryTreeNode * > q ;
BinaryTreeNode * temp ;
if ( p == root )
{
Q.push(p);
p=NULL;
}
if (Q.empty())
{
return 0;
}
while(!Q.empty())
{
temp=Q.front();
Q.pop();
if (temp->lc)
{
q.push(temp->lc);
}
if (temp->rc)
{
q.push(temp->rc);
}
n++;
}
if (Width(p,q) > n)
{
n = Width(p,q);
}

return n;
}
void BinaryTree::Delete(BinaryTreeNode * p)
{
if (p->lc==NULL&&p->rc==NULL)
{
delete p;
root=NULL;
}
else
{
if (p->lc&&p->lc->lc==NULL&&p->lc->rc==NULL)
{
delete p->lc;
p->lc=NULL;
}
if (p->rc&&p->rc->lc==NULL&&p->rc->rc==NULL)
{
delete p->rc;
p->rc=NULL;
}
}
if (p->lc)
{
Delete(p->lc);
}
if (p->rc)
{
Delete(p->rc);
}
}
int BinaryTree::Max(BinaryTreeNode * p)
{
int n=0;
if (p == NULL)
{
return 0;
}
else
{
if (n<Max(p->lc))
{
n = Max(p->lc);
}
if (n<Max(p->rc))
{
n = Max(p->rc);
}
if (n<p->element)
{
n = p->element;
}
}
return n;

}
void BinaryTree::Swap(BinaryTreeNode * p)
{
if (p!=NULL)
{
BinaryTreeNode * temp;
temp=p->lc;
p->lc=p->rc;
p->rc=temp;
Swap(p->lc);
Swap(p->rc);
}
}
BinaryTreeNode * BinaryTree::GiveRoot()
{
return root;
}
void BinaryTree::Show()
{
queue<BinaryTreeNode *> q;
BinaryTreeNode * p=root;
if (p)
{
q.push(p);
}
while (!q.empty())
{
p=q.front();
cout<<p->element<<" ";
q.pop();
if (p->lc)
{
q.push(p->lc);
}
if (p->rc)
{
q.push(p->rc);
}
}
cout<<endl;
}
BinaryTreeNode * BinaryTree::Create(BinaryTreeNode * p)
{
int num;
cout<<"请输入数据"<<endl;
cin>>num;
if (num==0)
{
p=NULL;
}
else
{
p=new BinaryTreeNode(num);
p->lc=Create(p->lc);
p->rc=Create(p->rc);
}
root=p;
return p;
}
int BinaryTree::Degrees0(BinaryTreeNode * p)
{
if (p==NULL)
{
return 0;
}
if(p->lc==NULL&&p->rc==NULL)
{
return 1;
}
return Degrees0(p->lc)+Degrees0(p->rc);
}
int BinaryTree::Degrees1(BinaryTreeNode * p)
{
if (p==NULL)
{
return 0;
}
if((p->lc!=NULL&&p->rc==NULL)||(p->lc==NULL&&p->rc!=NULL))
{
return 1+Degrees1(p->lc)+Degrees1(p->rc);
}
return Degrees1(p->lc)+Degrees1(p->rc);
}
int BinaryTree::Degrees2(BinaryTreeNode * p)
{
if (p==NULL)
{
return 0;
}
if(p->lc!=NULL&&p->rc!=NULL)
{
return 1+Degrees2(p->lc)+Degrees2(p->rc);
}
if (p->lc!=0||p->rc!=0)
{
return Degrees2(p->lc)+Degrees2(p->rc);
}
return 0;
}
int BinaryTree::Height(BinaryTreeNode * p)
{
int h=0,lh,rh;
if (p==NULL)
{
h=0;
}
else
{
lh=Height(p->lc);
rh=Height(p->rc);
if (lh>=rh)
{
h=lh+1;
}
else
{
h=rh+1;
}
}
return h;
}
void Test()
{
BinaryTree b;
queue<BinaryTreeNode * > q;
b.Create(b.GiveRoot());
cout<<"度为0的结点个数为:"<<b.Degrees0(b.GiveRoot())<<endl;
cout<<"度为1的结点个数为:"<<b.Degrees1(b.GiveRoot())<<endl;
cout<<"度为2的结点个数为:"<<b.Degrees2(b.GiveRoot())<<endl;
cout<<"高度为："<<b.Height(b.GiveRoot())<<endl;
cout<<"树中最大元素的值为："<<b.Max(b.GiveRoot())<<endl;
cout<<"树的宽度为："<<b.Width(b.GiveRoot(),q)<<endl;
b.Show();
b.Swap(b.GiveRoot());
cout<<"交换左右子树之后：";
b.Show();
b.Swap(b.GiveRoot());
b.Show();
b.Delete(b.GiveRoot());
cout<<"删除叶子之后：";
b.Show();
}
void main()
{
Test();
}