算法5.1-5.6

第一关

 //算法5.1 中序遍历的递归算法
#include<iostream>
using namespace std;

typedef struct BiNode{				//二叉链表定义
	char data;
	struct BiNode *lchild,*rchild;
}BiTNode,*BiTree;

//用算法5.3 先序遍历的顺序建立二叉链表
void CreateBiTree(BiTree &T){	
	//按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T
	/***************************Begin**********************/
    char ch;
    cin >> ch;

    if(ch == '#') T = NULL;
    else
    {
        T = new BiTNode;
        T -> data = ch;
        CreateBiTree(T -> lchild);
        CreateBiTree(T -> rchild);
    }

    /***************************End************************/
}									//CreateBiTree

void InOrderTraverse(BiTree T){  
	//中序遍历二叉树T的递归算法
	/****************************Begin*******************/
    if(T)
    {
        InOrderTraverse(T -> lchild);
        cout << T -> data;
        InOrderTraverse(T -> rchild);
    }
    /****************************End************************/
}

int main(){
	BiTree tree;
	
	CreateBiTree(tree);

	InOrderTraverse(tree);
	cout<<endl;
}

第二关

//算法5.2 中序遍历的非递归算法
#include<iostream>
using namespace std;

//二叉树的二叉链表存储表示
typedef struct BiNode
{				
	char data;						//结点数据域
	struct BiNode *lchild,*rchild;	//左右孩子指针
}BiTNode,*BiTree;

//链栈的定义
typedef struct StackNode
{
	BiTNode data;
	struct StackNode *next;
}StackNode,*LinkStack;

//用算法5.3 先序遍历的顺序建立二叉链表
void CreateBiTree(BiTree &T)
{	
	//按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T
	char ch;
	cin >> ch;
	if(ch=='#')  T=NULL;			//递归结束，建空树
	else{							
		T=new BiTNode;
		T->data=ch;					//生成根结点
		CreateBiTree(T->lchild);	//递归创建左子树
		CreateBiTree(T->rchild);	//递归创建右子树
	}								//else
}									//CreateBiTree

void InitStack(LinkStack &S)
{
	//构造一个空栈S，栈顶指针置空
	S=NULL;
}

bool StackEmpty(LinkStack S)
{
	if(!S)
		return true;
	return false;
}

void Push(LinkStack &S,BiTree e)
{
	//在栈顶插入元素*e
	StackNode *p=new StackNode;
	p->data=*e;
	p->next=S;
	S=p;
}

void Pop(LinkStack &S,BiTree e)
{
	if(S!=NULL)//原书上写的是if(S==NULL)return ERROR;
	{	
		*e=S->data;
		StackNode *p=S;
		S=S->next;
		delete p;
	}
} 
  
void InOrderTraverse1(BiTree T)
{ 
  // 中序遍历二叉树T的非递归算法
	/********************************Begin*********************************/
    LinkStack S;
    InitStack(S);
    BiTree p = T;
    BiTree q = new BiTNode;

    while(p || !StackEmpty(S))
    {
        if(p) 
        {
            Push(S,p);
            p = p -> lchild;
        }
        else
        {
            Pop(S,q);
            cout << q -> data;
            p = q -> rchild;
        }
    }
    /********************************End**********************************/
}									// InOrderTraverse

int main()
{
	BiTree tree;

	CreateBiTree(tree);

	InOrderTraverse1(tree);
	cout<<endl;
}

第三关

//算法5.4 复制二叉树
#include<iostream>
using namespace std;

//二叉树的二叉链表存储表示
typedef struct BiNode
{				
	char data;						//结点数据域
	struct BiNode *lchild,*rchild;	//左右孩子指针
}BiTNode,*BiTree;

//用算法5.3建立二叉链表
void CreateBiTree(BiTree &T)
{	
	//按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T
	char ch;
	cin >> ch;
	if(ch=='#')  T=NULL;			//递归结束，建空树
	else{							
		T=new BiTNode;
		T->data=ch;					//生成根结点
		CreateBiTree(T->lchild);	//递归创建左子树
		CreateBiTree(T->rchild);	//递归创建右子树
	}								//else
}									//CreateBiTree

void Copy(BiTree T, BiTree &NewT)
{ 
	/***********************Begin******************/
    if(T == NULL)
    {
        NewT = NULL;
        return ;
    }
    else
    {
        NewT = new BiTNode;
        NewT -> data = T -> data;
        Copy(T -> lchild,NewT -> lchild);
        Copy(T -> rchild,NewT -> rchild);
    }
	/**********************End*******************/
}												//CopyBiTree

//用算法5.1 中序遍历的递归算法							
void InOrderTraverse(BiTree T)
{  
	//中序遍历二叉树T的递归算法
	if(T){
		InOrderTraverse(T->lchild);
		cout << T->data;
		InOrderTraverse(T->rchild);
	}
}
int main()
{
	BiTree tree,new_tree;
	
	CreateBiTree(tree);
	Copy(tree,new_tree);

	InOrderTraverse(new_tree);
	cout<<endl;
}

第四关

//算法5.5 计算二叉树的深度
#include<iostream>
using namespace std;

//二叉树的二叉链表存储表示
typedef struct BiNode
{				
	char data;						//结点数据域
	struct BiNode *lchild,*rchild;	//左右孩子指针
}BiTNode,*BiTree;

//用算法5.3建立二叉链表
void CreateBiTree(BiTree &T)
{	
	//按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T
	char ch;
	cin >> ch;
	if(ch=='#')  T=NULL;			//递归结束，建空树
	else{							
		T=new BiTNode;
		T->data=ch;					//生成根结点
		CreateBiTree(T->lchild);	//递归创建左子树
		CreateBiTree(T->rchild);	//递归创建右子树
	}								//else
}									//CreateBiTree

int Depth(BiTree T)
{ 
	/***********************Begin*************************/
    if(T == NULL) return 0;
    else
    {
        int m = Depth(T -> lchild);
        int n = Depth(T -> rchild);
        if(m > n) return m + 1;
        else return n + 1;
    }

	/***********************End**************************/
}

int main()
{
	BiTree tree;

	CreateBiTree(tree);
	cout << Depth(tree) << endl;

}

第五关

//算法5.6 统计二叉树中结点的个数
#include<iostream>
using namespace std;

//二叉树的二叉链表存储表示
typedef struct BiNode
{				
	char data;						//结点数据域
	struct BiNode *lchild,*rchild;	//左右孩子指针
}BiTNode,*BiTree;

//用算法5.3建立二叉链表
void CreateBiTree(BiTree &T)
{	
	//按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T
	char ch;
	cin >> ch;
	if(ch=='#')  T=NULL;			//递归结束，建空树
	else{							
		T=new BiTNode;
		T->data=ch;					//生成根结点
		CreateBiTree(T->lchild);	//递归创建左子树
		CreateBiTree(T->rchild);	//递归创建右子树
	}								//else
}									//CreateBiTree

int NodeCount(BiTree T)
{
    /*********************Begin***********************/
    if(T == NULL) return 0;
    else return NodeCount(T -> lchild) + NodeCount(T -> rchild) + 1;
    /********************End*************************/
} 

int main()
{
	BiTree tree;

	CreateBiTree(tree);
	cout << NodeCount(tree) << endl;

}