二叉树基本操作实现

// BiTree_02.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

/****************************************************************************/
/*  １、问题描述：很多涉及二叉树的操作的算法都是以二叉树的遍历操作为基础的。*/
/*  编写程序，对一棵给定的二叉树进行先、中、后三种次序的遍历。              */
/*  ２、基本要求：以二叉链表为存储结构，实现二叉树的先、中、后三种次序的递  */
/*  归和非递归遍历。                                                        */
/*  ３、测试数据：以教科书图6.9的二叉树为例。                               */
/*  ４、实现提示：                                                          */
/*  　　（１）、设二叉树的结点不超过30个，且每个结点的数据均为字符，这样可  */
/*  利用先序遍历序列作为输入顺序创建二叉树链表存储结构。                    */
/*  　　（２）、也可利用完全二叉树在顺序存储中的特性，创建二叉树的存储结构，*/
/*  此时，二叉树中结点数据的类型不受限制。                                  */
/*  ５、选作内容：                                                          */
/*  　　（１）、借助队列，实现二叉树的层序遍历。                            */
/*  　　（２）、按凹入表或树形打印所遍历的二叉树。                          */
/****************************************************************************/
#include<iostream>
#include<fstream>
#include<string>
#include<stack>
#include<stdlib.h>
//#include<stdio.h>
//#include<malloc.h>
using namespace std;
//--------------------------------------------------
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef char TElemtype;
const int MaxLength = 30;//二叉树的结点不超过30个
typedef struct BiTNode{//二叉树结点结构
TElemtype data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//--------------------------------------------------
class BinaryTree{
private:
BiTree T;
public:
int CreateBiTree(BiTree &T,ifstream &in);
//递归遍历
void PreOrder(BiTree &T);
void InOrder(BiTree &T);
void PostOrder(BiTree &T);
//层序遍历
void LevelOrder(BiTree T);
//非递归遍历
void RePreOrder(BiTree &T);
void ReInOrder(BiTree &T);
void RePostOrder(BiTree &T);

bool Complete(BiTree T);
int Depth(BiTree T);
int Countleaf(BiTree T);
int Countleafs(BiTree T);
};//BinaryTree
//--------------------------------------------------
void main(){
ofstream out("data.txt");
/*  if(out){
for(char i = 65; i < 70; i++)
out << i;// << '#' << char(i + 7);
out << "###############";
}
*/
//  out << "AB##C##";
//  out << "ABC##D##EF##G##";
//  out << "ABCD##E##FG##H##IJK##L##MN##O##";
out << "ABCD##E##FG##H##IJK##L##MN####";
out.close();

cout<<"按先序序列输入二叉树中结点的值,如：\n-+a##*b##-c##d##/e##f##\n";
ifstream in("data.txt");
BinaryTree bt;
BiTree tree;
bt.CreateBiTree(tree,in);
in.close();
cout<<"二叉树创建完成!\n";
cout<<"----------------\n";

cout<<"递归遍历：\n";
cout<<"先序遍历二叉树：\n";
bt.PreOrder(tree);
cout<<endl;

cout<<"中序遍历二叉树：\n";
bt.InOrder(tree);
cout<<endl;

cout<<"后序遍历二叉树：\n";
bt.PostOrder(tree);
cout<<endl;

cout<<"----------------\n";

cout<<"非递归遍历：\n";
cout<<"先序遍历二叉树：\n";
bt.RePreOrder(tree);
cout<<endl;

cout<<"中序遍历二叉树：\n";
bt.ReInOrder(tree);
cout<<endl;

cout<<"后序遍历二叉树：\n";
bt.RePostOrder(tree);
cout<<endl;

cout<<"----------------\n";
cout<<"层序遍历二叉树是否为完全二叉树：";
if(bt.Complete(tree))
cout<<"是\n";
else
cout<<"不是\n";

cout<<"此二叉树的深度为："<<bt.Depth(tree)<<endl;
cout<<"此二叉树的总结点个数为："<<bt.Countleafs(tree)<<endl;
cout<<"此二叉树的叶子结点个数为："<<bt.Countleaf(tree)<<endl;
}
//--------------------------------------------------
int BinaryTree::CreateBiTree(BiTree &T,ifstream &in){
//按先序序列输入二叉树中结点的值，空格字符表示空树，
//构造二叉树表表示的二叉树T；
char ch;
in>>ch;
if(ch == '#') T = NULL;
else{
T = (BiTNode*)malloc(sizeof(BiTNode));
if(T == NULL) return ERROR;//*/if(!(T = new BiTNode)) exit(OVERFLOW);
T -> data = ch;//生成根节点
int temp = CreateBiTree(T -> lchild,in) + CreateBiTree(T -> rchild,in);//构造右子树
//       CreateBiTree(T -> lchild,in)//构造左子树
//       CreateBiTree(T -> rchild,in);//构造右子树
}//else
return OK;
}//CreateBiTree
//--------------------------------------------------
void BinaryTree::PreOrder(BiTree &T){//递归函数：先序遍历以T为根的二叉树
if(T != NULL){//递归结束条件
cout<<T -> data<<" ";//访问根节点
PreOrder(T -> lchild);//先序遍历根节点的左子树
PreOrder(T -> rchild);//先序遍历根节点的右子树

}
}//PreOrder
//--------------------------------------------------
void BinaryTree::InOrder(BiTree &T){//递归函数：中序遍历以T为根的二叉树
if(T != NULL){//递归结束条件
InOrder(T -> lchild);//中序遍历根节点的左子树
cout<<T -> data<<" ";//访问根节点
InOrder(T -> rchild);//中序遍历根节点的右子树
}
}//InOrder
//--------------------------------------------------
void BinaryTree::PostOrder(BiTree &T){//递归函数：后序遍历以T为根的二叉树
if(T != NULL){//递归结束条件
PostOrder(T -> lchild);//后序遍历根节点的左子树
PostOrder(T -> rchild);//后序遍历根节点的右子树
cout<<T -> data<<" ";//访问根节点
}
}//PostOrder
//--------------------------------------------------
void BinaryTree::RePreOrder(BiTree &T){//非递归函数：先序遍历以T为根的二叉树
stack<BiTree> s;
s.push(T);//根指针进栈
while(!s.empty()){
BiTree b = s.top();
if(!s.empty()){//访问结点
b = s.top();
s.pop();
if(b -> data == NULL) cout<<"error";
else
cout<<b -> data<<" ";
}//if
if(b -> rchild) s.push(b -> rchild); //若右孩子存在，则入栈
if(b -> lchild) s.push(b -> lchild); //若左孩子存在，则入栈
}//while
}//RePreOrder
//--------------------------------------------------
void BinaryTree::ReInOrder(BiTree &T){//非递归函数：中序遍历以T为根的二叉树
stack<BiTree> s;
s.push(T);//根指针进栈
while(!s.empty()){
BiTree b = s.top();
while(b){//向左走到尽头
s.push(b -> lchild);
b = s.top();
}//while
s.pop();//空指针退栈
if(!s.empty()){//访问结点，向右一步
b = s.top();
s.pop();
if(b -> data == NULL) cout<<"error";
else
cout<< b -> data<<" ";
s.push(b -> rchild);
}//if
}//while
}//ReInOrder
//--------------------------------------------------
void BinaryTree::RePostOrder(BiTree &T){//非递归函数：后序遍历以T为根的二叉树
stack<BiTree> s;
BiTree r,p;//使用r标记访问过的右子树
p = T;
while(p||!s.empty())
{
if(p)
{
s.push(p);
p = p -> lchild;
}//if
else
{
p = s.top();
if(p -> rchild && p -> rchild != r)
{
p = p -> rchild;
s.push(p);
p = p-> lchild;
}
else
{
s.pop();
cout<<p->data<<" ";
r = p;
p = NULL;
}
}//else
}//while
}//RePostOrder
//--------------------------------------------------
void BinaryTree::LevelOrder(BiTree T){//借助队列，层序遍历
BiTree Q[MaxLength];
int front = 0;
int rear = 0;
BiTree p;
if(T){//根节点入队
Q[rear] = T;
rear = (rear + 1) % MaxLength;
}
while(front != rear){
p = Q[front];
cout<<p -> data<<" ";
front = (front + 1) % MaxLength;//队头元素出队

if(p -> lchild){//左孩子不为空，入队
Q[rear] = p -> lchild;
rear = (rear + 1) % MaxLength;
}
if(p -> rchild){//右孩子不为空，入队
Q[rear] = p -> rchild;
rear = (rear + 1) % MaxLength;
}
}//while
}//LevelOrder
//--------------------------------------------------
bool BinaryTree::Complete(BiTree T){//是否为完全二叉树
BiTree Q[MaxLength];
int front = 0;
int rear = 0;
BiTree p;

if(T == NULL)return true;//!T 即T == NULL
else{
Q[rear] = T;//根节点入队
rear = (rear + 1) % MaxLength;
while(front != rear){//队列不空
p = Q[front];
front = (front + 1) % MaxLength;//队头元素出队

if(p){
Q[rear] = p -> lchild;//左孩子入队
rear = (rear + 1) % MaxLength;

Q[rear] = p -> rchild;//右孩子入队
rear = (rear + 1) % MaxLength;
}//if
else{
while(front != rear){//队列不空
p = Q[front];
if(p) return false;
return true;
}//while
}//else
}//while
return true;//队列空则返回是
}//else
}//Complete
//--------------------------------------------------
int BinaryTree::Depth(BiTree T){
int depthval,depthleft,depthright;
if(T == NULL) depthval = 0;
else{
depthleft = Depth(T -> lchild);
depthright = Depth(T -> rchild);
depthval = 1 + (depthleft > depthright ? depthleft : depthright);
}//else
return depthval;
}//Depth
//--------------------------------------------------
int BinaryTree::Countleaf(BiTree T){//二叉树的叶子结点个数
int m,n;
if(!T) return 0;
if(!T -> lchild && !T -> rchild) return 1;
else {
m = Countleaf(T -> lchild);
n = Countleaf(T -> rchild);
return(m + n);
}//else
}//Countleaf
//--------------------------------------------------
int BinaryTree::Countleafs(BiTree T){//二叉树的总结点个数
int m,n;
if(!T) return 0;
if(!T -> lchild && !T -> rchild) return 1;
else {
m = Countleafs(T -> lchild);
n = Countleafs(T -> rchild);
return(m + n + 1);
}//else
}//Countleafs