高分求一个二叉树的创建和遍历

Question

要求
先用
struct treeNode
{
char data;
treeNode *lchild,*rchild;
}; //定义一个节点
然后用类
class binaryTree
{
private:
treeNode *T;
public:
binaryTree(); //构造函数
int createTree();//创建树
int preTravel();//先序遍历树
int inTravel();//中序遍历树
};
void main()
{
……
}
这个空指针用#输入表示
大概就这样吧
麻烦下大家帮我完成下
不要用模板template
请用类实现，并且只要创建二叉树，先序遍历，中序遍历，后序遍历中的2种遍历即可，如果有现成的程序可以直接摘抄过来，但是只需要完成这几种功能的函数皆可，其余的不要
编出来的结果是一个完整的cpp，可以直接运行
如果有高手，麻烦帮我现成编一个

Answer 1

说明：输入时按前序遍历方式依次输入各节点值，默认的结束符为0。即当一个节点为叶子节点时，把它的左子节点和右子节点都输为0，当然你可以自己修改为加别的值。例如某棵树的形状如下：
A
/ \
B C
/ \ \
D E F
则按如下输入：ABD00E00C0F00。

程序运行后结果如下：

前序遍历结果：
ABDECF
中序遍历结果：
DBEACF

程序源文件：

#include <stdio.h>
#include <stdlib.h>

struct treeNode
{
char data;
struct treeNode *lchild;
struct treeNode *rchild;
}; //定义一个节点

class binaryTree
{
private:
struct treeNode *T;
public:
binaryTree() {T = NULL;}; //构造函数
int createTree(); //创建树
int preTravel(); //先序遍历树
int inTravel(); //中序遍历树
};

struct treeNode * createBT(struct treeNode *bt, int k)
{
char b;
struct treeNode *p, *t;
b = getchar();
if (b != '0')
{
p = (struct treeNode *)malloc(sizeof(struct treeNode));
p->data = b;
p->lchild = NULL;
p->rchild = NULL;
if (k == 0) t = p;
if (k == 1) bt->lchild = p;
if (k == 2) bt->rchild = p;
createBT(p, 1);
createBT(p, 2);
}
return t;
}

void preTravelBT(struct treeNode *bt)
{
if (bt != NULL)
{
putchar(bt->data);
preTravelBT(bt->lchild);
preTravelBT(bt->rchild);
}
}

void inTravelBT(struct treeNode *bt)
{
if (bt != NULL)
{
inTravelBT(bt->lchild);
putchar(bt->data);
inTravelBT(bt->rchild);
}
}

int binaryTree::createTree()
{
printf("请输入各节点数据：\n");
T = createBT(T, 0);
return 0;
}

int binaryTree::preTravel()
{
printf("前序遍历结果：\n");
preTravelBT(T);
printf("\n");
return 0;
}

int binaryTree::inTravel()
{
printf("中序遍历结果：\n");
inTravelBT(T);
printf("\n");
return 0;
}

void main()
{
binaryTree MyTree;
MyTree.createTree();
MyTree.preTravel();
MyTree.inTravel();
}

Answer 2

void PreOrder_Nonrecursive(Bitree T)//先序遍历二叉树的非递归算法
{//思路为利用自己的堆栈模拟函数递归调用时栈区的变化。
InitStack(S);//初始化堆栈。参照严蔚敏编《数据结构C语言版》实现堆栈的相关功能函数，这里会用到。
Push(S,T); //根指针进栈
while(!StackEmpty(S))
{
while(Gettop(S,p)&&p)//若栈顶元素不是空指针
{
visit(p->data);//访问
push(S,p->lchild);//进入左子树
} //向左走到尽头
pop(S,p);将栈顶元素（实际上是空指针）丢弃
if(!StackEmpty(S))
{
pop(S,p);
push(S,p->rchild); //向右一步，从这个结点开始继续进行先序遍历
}
}//while
}//PreOrder_Nonrecursive

int NodeCount_BiTree(Bitree T)//求二叉树中结点的数目
{
if(!T) return 0; //递归结束条件：空树结点数为0
else return (NodeCount(T->lchild)+NodeCount(T->rchild)+1);//二叉树中结点数＝左子树的结点数＋右子树的结点数＋根结点自己
}//NodeCount_BiTree

int LeafCount_BiTree(Bitree T)//求二叉树中叶子结点的数目
{
if(!T) return 0; //空树没有叶子
else if(!T->lchild&&!T->rchild) return 1; //叶子结点
else return Leaf_Count(T->lchild)+Leaf_Count(T->rchild);//左子树的叶子数加上右子树的叶子数
}//LeafCount_BiTree

若已知二叉树的结点数为n，叶子的结点数为n0，那么n2=n0-1，n1=n-n2-n0=n-2n0+1。或者用以下算法
int n1=0;//定义全局变量n1
void Count_n1(Bitree T)
{//先序遍历二叉树过程中统计度为1的结点数
if(T)
{
if((T->lchild && !T->rchild) || (!T->lchild && T->rchild))//判断是否是度为1的结点，实际上是异或
n1++;
Count_n1(T->lchild);
Count_n1(T->rchild);
}
}

int Get_Depth(Bitree T)//求二叉树深度的递归算法
{
if(!T) return 0;//递归结束条件：空树深度为0
else
{
m=Get_Depth(T->lchild);
n=Get_Depth(T->rchild);
return (m>n?m:n)+1;//二叉树深度为其左右子树较大深度＋1
}
}//Get_Depth

参考资料：http://zhidao.baidu.com/question/74134042.html?si=1&wtp=wk

Answer 3

/*
* main.cpp
*
* Created on: 2008-12-1
* Author: Admin
*/
#include<iostream>
using std::cout;
using std::cin;
struct treeNode
{
char data;
treeNode *lchild,*rchild;
}; //定义一个节点
class binaryTree
{
private:
treeNode *TreeRoot;
void subCreate(treeNode *,int,const char *);
void Free(treeNode *);
void subpreTravel(treeNode *);
void subinTravel(treeNode *);
public:
binaryTree(){TreeRoot=new treeNode;}//构造函数
void createTree();//创建树
void preTravel(){subpreTravel(TreeRoot);cout<<"\n";}//先序遍历树
void inTravel(){subinTravel(TreeRoot);cout<<"\n";}//中序遍历树
~binaryTree(){Free(TreeRoot);}
};
void binaryTree::subCreate(treeNode * T,int root,const char * strNode)
{
static int longth=strlen(strNode);
int R=2*(root+1);
int L=2*(root+1)-1;
if(root ==0)
T->data=strNode[0];
if(L<longth)
{
T->lchild=new treeNode;
T->lchild->data=strNode[L];
subCreate(T->lchild,L,strNode);
}
else
T->lchild=NULL;

if(R<longth)
{
T->rchild=new treeNode;
T->rchild->data=strNode[R];
subCreate(T->rchild,R,strNode);
}
else
T->rchild=NULL;
}
void binaryTree::createTree()
{
subCreate(this->TreeRoot,0,"abcdefghijk");
}
void binaryTree::subpreTravel(treeNode * T)
{
if(T==NULL)
return;
cout<<T->data;
subpreTravel(T->lchild);
subpreTravel(T->rchild);
}
void binaryTree::subinTravel(treeNode * T)
{
if(T==NULL)
return;
subinTravel(T->lchild);
cout<<T->data;
subinTravel(T->rchild);
}
void binaryTree::Free(treeNode * T)
{
if(T==NULL)return;
if(T->lchild==NULL&&T->rchild==NULL)
delete T;
else
{
Free(T->lchild);
Free(T->rchild);
}
}
int main()
{
binaryTree BT;
BT.createTree();
BT.preTravel();
BT.inTravel();
return 0;
}
//用二叉堆的方式建树

Answer 4

//BinaryTree.h

#include "BinaryTreeNode.h"
template<class T>
class BinaryTree
{
public:
BinaryTree(){root=0;};
~BinaryTree(){};
bool IsEmpty() const{return (root==0);}
bool Root(T& x)const;
void MakeTree(const T& element,BinaryTree<T>& left,BinaryTree<T>& right);
void BreakTree(const T& element,BinaryTree<T>& left,BinaryTree<T>& right);
void PreOrder(BinaryTreeNode<T> *n);
BinaryTreeNode<T>* GetRoot();
private:
BinaryTreeNode<T> *root;//根节点
};
template<class T>
BinaryTreeNode<T>* BinaryTree<T>::GetRoot()
{
return root;
}
template<class T>
bool BinaryTree<T>::Root(T& x)const
{
if(root)
{
x=root->data;
return true;
}else
return false;
}
template<class T>
void BinaryTree<T>::MakeTree(const T& element,BinaryTree<T>& left,BinaryTree<T>& right)
{
root=new BinaryTreeNode<T>(element,left.root,right.root);
left.root=right.root=0;
}
template<class T>
void BinaryTree<T>::PreOrder(BinaryTreeNode<T> *n)
{
if(n)
{
cout<<n->data<<endl;
PreOrder(n->LeftChild);
PreOrder(n->RightChild);
}
}

//BinaryTreeNode.h

template<class T>
class BinaryTreeNode
{
public:
BinaryTreeNode(){LeftChild=RightChild=0};
BinaryTreeNode(const T& e)
{
data=e;
LeftChild=RightChild=0;
}
BinaryTreeNode(const T& e,BinaryTreeNode<T> *l,BinaryTreeNode<T> *r)
{
data=e;
LeftChild=l;
RightChild=r;
}
T data;
BinaryTreeNode<T> *LeftChild,//左子树
*RightChild;//右子树
};

Answer 5

//二叉树的实现
//了解更多请查看gdgzzch.blog.163.com 的《霍夫曼树》
//---------------------------------------------------------------------
//bintree.h
//用指针实现的二叉树
//Type 类型必须有重载<<与>>及＝运算

#ifndef BINTREE
#define BINTREE

#include <assert.h>
#include <iostream.h>

int Max(int a,int b)
{
return a>b?a:b;
}

template <class Type>
class BinaryTree;

template <class Type>
class BinTreeNode
{
friend class BinaryTree<Type>;
public:
BinTreeNode():leftchild(NULL),rightchild(NULL){};
BinTreeNode(Type item,BinTreeNode<Type> *left = NULL,BinTreeNode<Type> *right=NULL)
:data(item),leftchild(left),rightchild(right){};
Type GetData()const { return data; }
BinTreeNode<Type> *GetLeft()const { return leftchild; }
BinTreeNode<Type> *GetRight()const { return rightchild; }
void SetData(const Type &item){ data=item; }
void SetLeft(BinTreeNode <Type> *L){ leftchild = L; }
void SetRight(BinTreeNode <Type> *R){ rightchild = R; }
private:
BinTreeNode<Type> *leftchild, *rightchild;
Type data;
};

template <class Type>
class BinaryTree
{
public:
BinaryTree():root(NULL){};
BinaryTree(const BinaryTree<Type> &bt){ root=Copy(bt.root);}
BinaryTree(const Type &temp,const BinaryTree<Type> &bt1,const BinaryTree<Type> &bt2);
BinaryTree(Type value):RefValue(value),root(NULL){};
void operator =(const BinaryTree<Type> &bt);
virtual ~BinaryTree(){ Destroy(root); }
void Destroy(){Destroy(root);root=NULL; }

virtual int IsEmpty(){ return root==NULL?1:0; }
virtual BinTreeNode <Type> *Parent(BinTreeNode <Type> *current)
{
return root==NULL||root==current? NULL : Parent(root,current);
}
virtual BinTreeNode <Type> *LeftChild(BinTreeNode <Type> *current)
{
return root!=NULL? current->leftchild : NULL;
}
virtual BinTreeNode <Type> *RightChild(BinTreeNode <Type> *current)
{
return root!=NULL? current->rightchild : NULL;
}
virtual int Insert(const Type &item);
virtual int Find(const Type &item)const;
BinTreeNode <Type> *GetRoot()const{ return root; }
friend int Equal(BinTreeNode<Type> *a,BinTreeNode<Type> *b);
friend int operator ==(const BinaryTree<Type> &bt1,const BinaryTree<Type> &bt2);
friend istream& operator >>(istream &in, BinaryTree<Type> &Tree);
friend ostream& operator <<(ostream &out,BinaryTree<Type> &Tree );

void InOrder(); //遍历
void PreOrder();
void PostOrder();
//****************************************** //一些应用
int Size(){ return Size(root);} //统计结点数
int Depth(){ return Depth(root);} //计算树的深度
int Leaves(){ return Leaves(root);}
int Degrees1(){ return Degrees1(root);}
int Degrees2(){ return Degrees2(root);}
protected:
BinTreeNode <Type> *root;
Type RefValue;
BinTreeNode<Type> *Parent(BinTreeNode<Type> *start,BinTreeNode<Type> *current);
int Insert (BinTreeNode<Type> *current,const Type &item);
int Find(BinTreeNode<Type> *current,const Type &item)const;
BinTreeNode<Type>* Copy(BinTreeNode<Type> *originode);
void Destroy(BinTreeNode<Type> *current);

//******************************************
void InOrder(BinTreeNode<Type> *current);
void PreOrder(BinTreeNode<Type> *current);
void PostOrder(BinTreeNode<Type> *current);
//****************************************** //一些应用
int Size(const BinTreeNode<Type> *t)const;
int Depth(const BinTreeNode<Type> *t)const;
int Leaves(const BinTreeNode<Type> *t)const;
int Degrees1(const BinTreeNode<Type> *t)const;
int Degrees2(const BinTreeNode<Type> *t)const;
};

template <class Type>
BinTreeNode<Type>* BinaryTree<Type>::Copy(BinTreeNode<Type> *orignode)
{
if(orignode==NULL)
return NULL;
BinTreeNode<Type> *temp=new BinTreeNode<Type>;
temp->data=orignode->data;
temp->leftchild=Copy(orignode->leftchild);
temp->rightchild=Copy(orignode->rightchild);
return temp;
}

template <class Type>
BinaryTree<Type>::BinaryTree(const Type &temp,const BinaryTree<Type> &bt1,const BinaryTree<Type> &bt2)
{
root=new BinTreeNode<Type>(temp,Copy(bt1.root),Copy(bt2.root));
}

template <class Type>
void BinaryTree<Type>::operator =(const BinaryTree<Type> &bt1)
{
Destroy();
// Destroy(root);root=NULL; //为什么要这样？？？
root=Copy(bt1.root);
}

template<class Type>
void BinaryTree<Type>::Destroy(BinTreeNode<Type> *current)
{
if(current!=NULL)
{
Destroy(current->leftchild);
Destroy(current->rightchild);
delete current;
}
}

template<class Type>
BinTreeNode <Type>* BinaryTree<Type>::Parent(BinTreeNode<Type> *start,BinTreeNode<Type> *current)
{
if(start==NULL) return NULL;
if(start->leftchild==current || start->rightchild==current)
return start;
BinTreeNode <Type> *p=NULL;
if((p=Parent(start->leftchild, current))!=NULL) //在start的左子树中找
return p;
else
return Parent(start->rightchild,current);
}

template<class Type>
int BinaryTree<Type>::Insert(BinTreeNode<Type> *current,const Type &item)
{
if(current==NULL)
return 0;
BinTreeNode<Type> *p=new BinTreeNode<Type>(item,NULL,NULL);
if(current->leftchild==NULL)
current->leftchild=p;
else if(current->rightchild==NULL)
current->rightchild=p;
else
Insert(current->leftchild,item); //这样插可是构不成树状的！估且一用吧
return 1;
}

template<class Type>
int BinaryTree<Type>::Insert(const Type &item)
{
if(root==NULL)
{
root=new BinTreeNode<Type>(item,NULL,NULL);
return 1;
}
return Insert(root,item);
}

template<class Type>
int BinaryTree<Type>::Find(BinTreeNode<Type> *current,const Type &item)const
{
if(current==NULL)
return 0;
if(current->data==item)
return 1;
int k;
if((k=Find(current->leftchild,item))!=0)
return 1;
else
return Find(current->rightchild,item);
}

template<class Type>
int BinaryTree<Type>::Find(const Type &item)const
{
return Find(root,item);
}

template<class Type>
int Equal(BinTreeNode<Type> *a,BinTreeNode<Type> *b)
{
if(a==NULL&&b==NULL)
return 1;
if(a!=NULL&&b!=NULL&&a->GetData()==b->GetData()
&&Equal(a->GetLeft(),b->GetLeft())&&Equal(a->GetRight(),b->GetRight()))
return 1;
return 0;
}

template<class Type>
int operator ==(const BinaryTree<Type> &bt1,const BinaryTree<Type> &bt2)
{
return Equal(bt1.root,bt2.root);
}

template<class Type>
istream& operator>>(istream &in,BinaryTree<Type> &Tree)
{
Type item;
cout<<"构造二叉树:\n";
cout<<"输入数据(用"<<Tree.RefValue<<"结束): ";
in >> item;
while(item!=Tree.RefValue)
{
Tree.Insert(item);
cout<<"输入数据(用"<<Tree.RefValue<<"结束): ";
in>>item;
}
return in;
}

template<class Type>
ostream& operator<<(ostream &out,BinaryTree<Type> &Tree)
{
out<<"二叉树的前序遍历.\n";
Tree.PreOrder();
out<<endl;
return out;
}

//*****************************************************************************

template <class Type>
void BinaryTree <Type>::InOrder()
{
InOrder(root);
}

template <class Type> void BinaryTree<Type>::InOrder(BinTreeNode<Type> *current)
{
if(current!=NULL)
{
InOrder(current->leftchild);
cout << current->data<<' ';
InOrder(current->rightchild);
}
}

template <class Type>
void BinaryTree <Type>::PreOrder()
{
PreOrder(root);
}

template <class Type>
void BinaryTree<Type>::PreOrder(BinTreeNode<Type> *current)
{
if(current!=NULL)
{
cout<<current->data<<' ';
PreOrder(current->leftchild);
PreOrder(current->rightchild);
}
}

template <class Type>
void BinaryTree<Type>::PostOrder()
{
PostOrder(root);
}

template <class Type>
void BinaryTree<Type>::PostOrder(BinTreeNode<Type> *current)
{
if(current!=NULL)
{
PostOrder(current->leftchild);
PostOrder(current->rightchild);
cout<<current->data<<' ';
}
}

//*************************************************** //一些应用
template <class Type>
int BinaryTree<Type>::Size(const BinTreeNode<Type> *t)const
{
if(t==NULL)
return 0;
else
return 1+Size(t->leftchild)+Size(t->rightchild);
}

template <class Type>
int BinaryTree<Type>::Depth(const BinTreeNode<Type> *t)const
{
if(t==NULL)
return -1;
else
return 1+Max(Depth(t->leftchild),Depth(t->rightchild));
}

template <class Type>
int BinaryTree<Type>::Leaves(const BinTreeNode<Type> *t)const
{
if(t==NULL)
return 0;
if(t->leftchild==NULL&&t->rightchild==NULL) //t是叶子结点
return 1;
return Leaves(t->leftchild)+Leaves(t->rightchild);
}

template <class Type>
int BinaryTree<Type>::Degrees1(const BinTreeNode<Type> *t)const
{
if(t==NULL)
return 0;
if((t->leftchild==NULL&&t->rightchild!=NULL)
||(t->leftchild!=NULL&&t->rightchild==NULL)) //t的度为1
return 1+Degrees1(t->leftchild)+Degrees1(t->rightchild);
return Degrees1(t->leftchild)+Degrees1(t->rightchild);
}

template <class Type>
int BinaryTree<Type>::Degrees2(const BinTreeNode<Type> *t)const
{
if(t==NULL)
return 0;
if(t->leftchild!=NULL&&t->rightchild!=NULL) //t 的度为2
return 1+Degrees2(t->leftchild)+Degrees2(t->rightchild);
return Degrees2(t->leftchild)+Degrees2(t->rightchild);
}

#endif

参考资料：gdgzzch.blog.163.com

Answer 6

二叉树的类定义和实现
//btree.h//
tepmplate<class T>class BTree{
private:
BTree<T> *left;
BTree<T> *right;
public:
T data;
BTree(){left=right=NULL;}
BTree(T item,BTree<T> *left1=NULL,BTree<T> *righ1t=NULL):data (item),
left(left1),right(right1){}
BTree<T> *&left(){return left;}
BTree<T> *&right(){return right;}
void CreateBTree(char* a);
bool BTreeEmpty(){return left==NULL;}
void TraverseBTree(int mark);
void Traverse(BTree<T> *&BT,int mark);
int BtreeDepth();
int Depth(BTree<T> *&BT);
int BTreeCount();
int Count(BTree<T> *&BT);
int BTreeLeafCount();
int LeafCount(BTree<T> *&BT);
void PrintBTree();
void Print(BTree<T> *&BT);
void Clear(BTree<T> *&BT);
~BTree();
};
//btree.cpp//
template <class T>
void BTree<T>::CreateBTree(char *a)
{BTree<T> *s[80];
int top=-1;
left=NULL;
BTree<T> *p=NULL;
int k;
istrstream ins(a);
char ch;
ins>>ch;
while(ch!='#')
{
case '(':top++;s[top]=p;k=1;break;
case ')':top--;break;
case ',':top++;s[top]=p;k=2;break;
default:p=new BTree<T>;
p->data=ch;p->left=p->right=NULL;
count<<setw(2)<<p->data;
if(left==NULL) left=p;
else{
if(k==1) s[top]->left=p;
else s[top]->right=p;}
}
ins>>ch;
}
}
template <class T>
void BTree<T>::TraverseBTree(int mark)
{Traverse(left,mark);}
template <class T>
void BTree<T>::TraverseBTree(BTree<T> *&BT,int mark)
{if(mark==1){
if(BT!=NULL)
{count<<BT->data<<' ';
Traverse(BT->left,mark);
Traverse(BT->right,mark);
}}
else
if(mark==2){
if(BT!=NULL)
Traverse(BT->left,mark);
count<<BT->data<<' ';
Traverse(BT->right,mark);
}}
else
if(mark==3){
if(BT!=NULL)
Traverse(BT->left,mark);
Traverse(BT->right,mark);
count<<BT->data<<' ';
}}
else
if(mark==4){
const MaxLength=80;
BTree<T> *Q[MaxLength];
int front=0,rear=0;
BTree<T> *p;
if(BT!=NULL){
rear=(rear+1)%MaxLength;
Q[rear]=BT;
while(front!=rear)
{
front=(front+1)%MaxLength;
p=Q[front];
count<<p->data<<' ';
if(p->left!=NULL)
rear=(rear+1)%MaxLength;
Q[rear]=p->left;
}
if(p->right!=NULL)
{
rear=(rear+1)%MaxLength;
Q[rear]=p->right;
}
}
}
else
{cerr<<"mark的值失效！遍历失败！"<<endl;exit(1);
}}
template <class T>
int BTree<T>::BTreeDepth()
{return Depth(left);}
template <class T>
int BTree<T>::Depth(BTree<T> *&BT)
{if(BT==NULL) return 0;
else
{int dep1=Depth(BT->left);
int dep2=Depth(BT->right);
if(dep1>dep2) return dep1+1;
else return dep2+1;
}
}
template <class T>
int BTree<T>::BTreeCount()
{return Count(left);}
template <class T>
int BTree<T>::Count(BTree<T> *&BT)
{if(BT==NULL) return 0;
else
return Count(BT->left)+Count(BT->right)+1;
}
template <class T>
int BTree<T>::BTreeLeafCount()
{return LeafCount(left);}
template <class T>
int BTree<T>::LeafCount(BTree<T> *&BT)
{if(BT==NULL) return 0;
else if(BT->left==NULL&&BT->right==NULL) return 1;
else return LeafCount(BT->left)+LeafCount(BT->right);
}
template <class T>
void BTree<T>::PrintBTree()
{Print(left);}
template <class T>
void BTree<T>::PrintBTree(BTree<T> *&BT)
{if(BT==NULL) return ;
else{
cout<<BT->data;
if(BT->left!=NULL||BT->right!=NULL)
{if(BT->left!=NULL)
cout<<'(';
Print(BT->left);
if(BT->right!=NULL)
cout<<',';
Print(BT->left);
if(BT->left!=NULL&&BT->right!=NULL)cout<<')';}
}}
template <class T>
BTree<T>::~BTree()
{Clear(left);}
template <class T>
BTree<T>::Clear(BTree<T> *&BT)
{if(BT==NULL)
{
Clear(BT->left);
Clear(BT->right);
delete BT;
BT=NULL;}
}
//btreeM.cpp//
#include<iostream.h>
#include<iomanip.h>
#include<stdlib.h>
#include<strstrea.h>
#include "btree.h"
#include "btree.cpp"
void main()
{cout<<"btreeM.cpp 运行结果:\n";
int n;
char a[80]="(a)(b),c(d),e(f),g(h),i(j),k(l),m(n),o#";
BTree<char> B;
cout<<"创建的二叉树为:\n";
B.CreateBTree(a);cout<<end1;
if(!B.BTreeEmpty())
cout<<"二叉树非空!:\n";
else
cout<<"二叉树为空!:\n";
cout<<"先序遍历二叉树:\n"；
B.TraverseBTree(1);cout<<endl;
cout<<"中序遍历二叉树:\n"；
B.TraverseBTree(2);cout<<endl;
cout<<"后序遍历二叉树:\n"；
B.TraverseBTree(3);cout<<endl;
cout<<"按层遍历二叉树:\n"；
B.TraverseBTree(4);cout<<endl;
n=B.BTreeDepth();
cout<<"二叉树的深度="<<n<<endl;
n=B.BTreeCount();
cout<<"二叉树的所有节点数="<<n<<endl;
n=B.BTreeLeafCount();
cout<<"二叉树的所有叶子节点数="<<n<<endl;
cout<<"按二叉树的广义表输出:\n(";
B.PrintBTree();cout<<')'<<endl
cin.get();}