二叉树的基本操作（C++）

//程序名：btree.cpp
//      程序功能：二叉树的基本操作（包括建立、输出、前序遍历、中序遍历、后序遍历、求树高、统计叶子总数等）
//          作者：wangdahao
//          日期：2011.11.9
//          版本：1.0
//      修改内容：无
//      修改日期：
//      修改作者：
//
//
//

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

typedef char T;      //为本程序定义所使用的具体数据类型

struct BTreeNode
{
 friend class BTree;
 T data;
 BTreeNode *lchild,*rchild;
};//BTreeNode

class BTree
{
public:
 void Create();
 int Depth();
 int Number();
 void PreOrder(void visit(BTreeNode *p));           //前序递归遍历算法
 void InOrder(void visit(BTreeNode *p));            //中序递归遍历算法
 void PostOrder(void visit(BTreeNode *p));          //后序递归遍历算法
 void PreOrder1(void visit(BTreeNode *p));          //前序非递归遍历算法
 void InOrder1(void visit(BTreeNode *p));           //中序非递归遍历算法
 void PostOrder1(void visit(BTreeNode *p));         //后序非递归遍历算法
 void LayerOrder(void visit(BTreeNode *p));         //层次遍历算法
private:
 BTreeNode *root;
 BTreeNode *CreateBTree();   //建立二叉树
 int Depth(BTreeNode *p);    //树高
 int Number(BTreeNode *p);   //叶子结点个数
 void PreOrder(BTreeNode *p,void visit(BTreeNode *p));
 void InOrder(BTreeNode *p,void visit(BTreeNode *p));
 void PostOrder(BTreeNode *p,void visit(BTreeNode *p));
};//BTree

//
//建立二叉树函数
//函数功能：建立一棵二叉链式结构
//函数参数：无
//参数返回值：
//       current:二叉链式结构结点类指针

BTreeNode * BTree::CreateBTree()
{
 BTreeNode * current;
 char ch;
 cin>>ch;
 if(ch=='.')  //判断输入的是否为“.”
  return NULL;     //建立空树
 else
 {
  current=new BTreeNode;
  current->data=ch;
  current->lchild=CreateBTree();
  current->rchild=CreateBTree();
  return current;
 }
}//CreateBTree

void BTree::Create()
{
 root=CreateBTree();
}//Create
//
//求树高函数
//函数功能：计算所建立的二叉树的高度
//函数参数：
//     p:二叉链式结构结点类指针
//参数返回值：
//     max:表示二叉树高度的整数

int BTree::Depth(BTreeNode *p)
{
 int max;
 if(p==NULL)
  return 0;
 else
 {
  max=Depth(p->lchild);
  if(Depth(p->rchild)>max)
   max=Depth(p->rchild);
  return (max+1);
 }
}//Depth

int BTree::Depth()
{
 return (Depth(root));
}//Depth

//
//求叶子结点个数函数
//函数功能：计算二叉树的叶子结点的个数
//函数参数：
//     p:二叉链式结构结点类指针
//参数返回值：无

int BTree::Number(BTreeNode *p)
{
 if(p==NULL)
  return 0;
 else
 {
  if((p->lchild==NULL)&&(p->rchild==NULL))
   return 1;
  else
      return Number(p->lchild)+Number(p->rchild);
 }
}//Number

int BTree::Number()
{
 return (Number(root));
}//Number

//
//前序递归遍历函数
//函数功能：用前序递归遍历算法访问二叉树
//函数参数：
//     p:二叉链式结构结点类指针
//     visit:函数指针
//参数返回值：无

void BTree::PreOrder(BTreeNode *p,void visit(BTreeNode *p))    //void visit(BTreeNode *p）为函数指针
{
 if(p!=NULL)
 {
  visit(p);
  PreOrder(p->lchild,visit);
  PreOrder(p->rchild,visit);
 }
}//PreOrder

void BTree::PreOrder(void visit(BTreeNode *p))
{
 PreOrder(root,visit);
 cout<<endl;
}//PreOrder

//
//前序非递归遍历函数
//函数功能：用前序非递归遍历算法遍历二叉树
//函数参数：
//     visit:函数指针
//参数返回值：无

void BTree::PreOrder1(void visit(BTreeNode *p))
{
 BTreeNode *p;
 stack <BTreeNode*>s;
 p=root;
 while(!s.empty()||p!=NULL)
 {
  while(p!=NULL)
  {
   visit(p);
   s.push(p);
   p=p->lchild;
  }
  if(!s.empty())
  {
   p=s.top(); s.pop();
   p=p->rchild;
  }//if
 }//while
}//PreOrder1

//
//中序递归遍历函数
//函数功能：用中序递归遍历算法访问二叉树
//函数参数：
//     p:二叉链式结构结点类指针
//     visit:函数指针
//参数返回值：无

void BTree::InOrder(BTreeNode *p,void visit(BTreeNode *p))
{
 if(p!=NULL)
 {
  InOrder(p->lchild,visit);
  visit(p);
  InOrder(p->rchild,visit);
 }
}//InOrder

void BTree::InOrder(void visit(BTreeNode *p))
{
 InOrder(root,visit);
 cout<<endl;
}//InOrder

//
//中序非递归遍历函数
//函数功能：用中序非递归遍历算法遍历二叉树
//函数参数：
//     visit:函数指针
//参数返回值：无

void BTree::InOrder1(void visit(BTreeNode *p))
{
 BTreeNode *p;
 stack <BTreeNode*>s;
 p=root;
 while(!s.empty()||p!=NULL)
 {
  while(p!=NULL)
  {
   s.push(p);
   p=p->lchild;
  }
  if(!s.empty())
  {
   p=s.top(); s.pop();
   visit(p);
   p=p->rchild;
  }//if
 }//while
}//InOrder1
//
//后序递归遍历函数
//函数功能：用后序递归遍历算法访问二叉树
//函数参数：
//     p:二叉链式结构结点类指针
//     visit:函数指针
//参数返回值：无

void BTree::PostOrder(BTreeNode *p,void visit(BTreeNode *p))
{
 if(p!=NULL)
 { 
  PostOrder(p->lchild,visit);
  PostOrder(p->rchild,visit);
  visit(p);
 }
}//PostOrder

void BTree::PostOrder(void visit(BTreeNode *p))
{
 PostOrder(root,visit);
 cout<<endl;
}//PostOrder

/
//后序非递归遍历函数
//函数功能：用后序非递归遍历算法遍历二叉树
//函数参数：
//     visit:函数指针
//参数返回值：无

void BTree::PostOrder1(void visit(BTreeNode *p))
{
 BTreeNode *p;
 BTreeNode *q=NULL;    //q指向已访问的结点
 stack <BTreeNode*>s;
 p=root;
 if(p!=NULL)
  s.push(p);
 while(!s.empty())
 {
  p=s.top(); s.pop();
  if(q==p->lchild||q==p->rchild)    //判断子树是否已访问
  {
   visit(p);
   q=p;
  }
  else
  {
   if(p->lchild!=NULL||p->rchild!=NULL)
   {
    s.push(p);
    if(p->rchild!=NULL)
     s.push(p->rchild);
    if(p->lchild!=NULL)
     s.push(p->lchild);
   }
   else
   {
    visit(p);
    q=p;
   }
  }//else
 }//while
}//PostOrder1

//
//层次遍历函数
//函数功能：用层次遍历算法遍历二叉树
//函数参数：
//     visit:函数指针
//参数返回值：无

void BTree::LayerOrder(void visit(BTreeNode *p))
{
 BTreeNode *p;
 queue <BTreeNode*>q;
 p=root;
 if(p!=NULL)
  q.push(p);
 while(!q.empty())
 {
  p=q.front(); q.pop();
  visit(p);
  if(p->lchild!=NULL)
   q.push(p->lchild);
  if(p->rchild!=NULL)
   q.push(p->rchild);
 }//while
}//LayerOrder

//
//输出函数
//函数功能：把二叉树输出
//函数参数：
//     p:二叉链式结构结点类指针
//参数返回值：无

void print(BTreeNode *p)
{
 cout<<p->data<<" ";
}//print

//
//主函数
//参数返回值：无

void main()
{
 BTree bt;
 int finished=0;
    int choice;
 int dep,num;
 while( !finished )
    {
  cout<<"*********Menu*********\n";
  cout<<"1:建立一棵二叉树\n";
        cout<<"2:前序遍历递归算法\n";
  cout<<"3:前序遍历非递归算法\n";
  cout<<"4:中序遍历递归算法\n";
  cout<<"5:中序遍历非递归算法\n";
  cout<<"6:后序遍历递归算法\n";
  cout<<"7:后序遍历非递归算法\n";
  cout<<"8:求树高\n";
  cout<<"9:求叶子总数\n";
  cout<<"10:输出二叉树\n";
  cout<<"11:退出\n";
  cout<<"Please choose a choice(1-11):";
  cin>>choice;
  switch(choice)
  {
  case 1:
   bt.Create();
   cout<<"建立的二叉树为:"<<endl;
   bt.PreOrder(print);
   break;
        case 2:
   bt.PreOrder(print);
   cout<<endl;
   break;
  case 3:
   bt.PreOrder1(print);
   cout<<endl;
   break;
  case 4:
   bt.InOrder(print);
   cout<<endl;
   break;
        case 5:
   bt.InOrder1(print);
   cout<<endl;
   break;
  case 6:
   bt.PostOrder(print);
   cout<<endl;
   break;
  case 7:
   bt.PostOrder1(print);
   cout<<endl;
   break;
  case 8:
   dep=bt.Depth();
   cout<<dep<<endl;
   break;
  case 9:
   num=bt.Number();
   cout<<num<<endl;
   break;
  case 10:
   bt.LayerOrder(print);
   cout<<endl;
   break;
        case 11:
   finished=1;//结束程序
   break;
 }  // switch
   } // while
}// main