目录
一、main
#include <iostream>
#include "com.h"
using namespace std;
int main()
{
int choice ;
BiTree T , NewT , p , q ;
do
{
printf("\t\t\t======================================================\n");
printf("\t\t\t| |\n");
printf("\t\t\t| 二叉树的基本操作 |\n");
printf("\t\t\t| |\n");
printf("\t\t\t|====================================================|\n");
printf("\t\t\t| 请选择要操作的命令 |\n");
printf("\t\t\t|----------------------------------------------------|\n");
printf("\t\t\t| |\n");
printf("\t\t\t| 1.建立一棵二叉树 2.先序遍历二叉树 |\n");
printf("\t\t\t| 3.中序遍历二叉树 4.后序遍历二叉树 |\n");
printf("\t\t\t| 5.求二叉树的深度 6.二叉树的节点总数 |\n");
printf("\t\t\t| 7.求叶子节点个数 8.单分支节点总数 |\n");
printf("\t\t\t| 9.双分支节点总数 10.交换左右子树 |\n");
printf("\t\t\t| 11.层序遍历 0.退出整个系统 |\n");
printf("\t\t\t|----------------------------------------------------|\n");
printf("\t\t\t| 附加指令 |\n");
printf("\t\t\t| 12.复制二叉树 13.先序非递归遍历 |\n");
printf("\t\t\t| 14.中序非递归遍历 15.后序非递归遍历 |\n");
printf("\t\t\t| 16.判断两个二叉树是否完全相同 |\n");
printf("\t\t\t| |\n");
printf("\t\t\t| |\n");
printf("\t\t\t======================================================\n");
printf("选择(0---16):\t");
cin >> choice ;
switch (choice)
{
case 0 : // 0.退出
cout << "退出成功" ;
cout << endl ;
break ; //return 0 ;
case 1 : //1.建立一棵二叉树
CreateBiTree(T) ;
cout << "创建成功" ;
cout << endl ;
break ;
case 2 : //2.先序遍历二叉树
cout << "遍历结果为:" ;
PreOrderTraverse(T) ;
cout << endl ;
break ;
case 3 : //3.中序遍历二叉树
cout << "遍历结果为:" ;
InOrderTraverse(T) ;
cout << endl ;
break ;
case 4 : //4.后序遍历二叉树
cout << "遍历结果为:" ;
PostOrderTraverse(T) ;
cout << endl ;
break ;
case 5 : //5.求二叉树的深度
cout << "二叉树的深度为:" << Depth(T) ;
cout << endl ;
break ;
case 6 : //6.二叉树的节点总数
cout << "二叉树的节点总数为:" << NodeCount(T) ;
cout << endl ;
break ;
case 7 :
cout << "二叉树的叶子节点总数为:" << LeafCount(T) ;
cout << endl ;
break ;
case 8 :
cout << "二叉树的单分支节点总数为:" << CountSingleeNode(T) ;
cout << endl ;
break ;
case 9 :
cout << "二叉树的双分支节点总数为:" << CountDoubleNode(T) ;
cout << endl ;
break ;
case 10 :
ChangeLeftRight(T) ;
cout << "交换成功" << endl ;
cout << "交换后的先序遍历:" ;
PreOrderTraverse(T) ;
cout << endl ;
cout << "交换后的中序遍历:" ;
InOrderTraverse(T) ;
cout << endl << endl ;
break ; //abd###c#e##
case 11 : // 11.层序遍历
cout << "遍历结果为:" ;
LevelOrder(T) ;
cout << endl ;
break ;
// 附加指令
case 12 : //12.复制二叉树
Copy(T , NewT) ;
cout << "复制成功" << endl ;
cout << "新树的先序遍历:" ;
PreOrderTraverse(NewT) ;
cout << endl ;
cout << "新树的中序遍历:" ;
InOrderTraverse(NewT) ;
cout << endl << endl ;
break ; //abd###c#e##
case 13 : // 先序非递归遍历
cout << "先序非递归遍历:" ;
PreOrder(T) ;
cout << endl ;
break ;
case 14 : //4.中序非递归遍历
cout << "中序非递归遍历:" ;
InOrder(T) ;
cout << endl ;
break ;
case 15 : // 后序非递归遍历
cout << "后序非递归遍历:" ;
// PostOrder(T) ;
cout << endl ;
break ;
case 16 ://16.判断两个二叉树是否完全相同
cout << "请输入树p:" ;
CreateBiTree(p) ;
cout << "请输入树q:" ;
CreateBiTree(q) ;
cout << "树p的先序遍历:" ;
PreOrderTraverse(p) ;
cout << endl ;
cout << "新p的中序遍历:" ;
InOrderTraverse(p) ;
cout << endl << endl ;
cout << "新q的先序遍历:" ;
PreOrderTraverse(q) ;
cout << endl ;
cout << "新q的中序遍历:" ;
InOrderTraverse(q) ;
cout << endl << endl ;
if(isSame(p , q)) cout << "两棵树相同" ;
else cout << "两棵树不相同" ;
cout << endl ;
break ;
default :
cout << "输入不合法,请重新输入" ;
cout << endl ;
}
}while(choice != 0) ;
return 0;
}
二、function
#include <iostream>
#include "com.h"
using namespace std;
// 1.建立一棵二叉树
void CreateBiTree(BiTree &T)
{
char ch ;
cin >> ch ;
if(ch == '#') T = NULL ; // 回溯
else
{
T = new BiTNode ;
T->data = ch ;
CreateBiTree(T->lchild) ;
CreateBiTree(T->rchild) ;
}
}
// 2.先序遍历二叉树
void PreOrderTraverse(BiTree T)
{
if(T)
{
cout << T->data << " " ;
PreOrderTraverse(T->lchild) ;
PreOrderTraverse(T->rchild) ;
}
}
// 3.中序遍历二叉树
void InOrderTraverse(BiTree T)
{
if(T)
{
InOrderTraverse(T->lchild) ;
cout << T->data << " " ;
InOrderTraverse(T->rchild) ;
}
}
// 4.后序遍历二叉树
void PostOrderTraverse(BiTree T)
{
if(T)
{
PostOrderTraverse(T->lchild) ;
PostOrderTraverse(T->rchild) ;
cout << T->data << " " ;
}
}
//5.求二叉树的深度
int Depth(BiTree T)
{
if(!T) return 0 ;
else
{
int m , n ;
m = Depth(T->lchild) ; // 左边的最大深度
n = Depth(T->rchild) ; // 右边的最大深度
return max(m , n) + 1 ; // 直接左右最大值加一
}
}
//6.二叉树的节点总数
int NodeCount(BiTree T)
{
if(T == NULL) return 0 ; //空,为零
else return NodeCount(T->lchild) + NodeCount(T->rchild) + 1 ; //左加右再加一
}
// 求叶子节点个数
int LeafCount(BiTree T)
{
if(T == NULL) return 0 ;
if(T->lchild == NULL && T->rchild == NULL) return 1 ;
else return LeafCount(T->lchild) + LeafCount(T->rchild) ;
}
// 单分支节点数
int CountSingleeNode(BiTree T)
{
int num = 0 ;
if(T)
{
if((T->lchild == NULL && T->rchild != NULL) || (T->lchild != NULL && T->rchild == NULL))
num ++ ;
num += CountSingleeNode(T->lchild) ;
num += CountSingleeNode(T->rchild) ;
}
return num ;
}
// 双分支
int CountDoubleNode(BiTree T)
{
int num = 0;
if (T)
{
if (T->lchild != NULL && T->rchild != NULL)
num ++ ;
num += CountDoubleNode(T->lchild);
num += CountDoubleNode(T->rchild);
}
return num;
}
// 交换左右子树
void ChangeLeftRight(BiTree &T)
{
BiTree temp ;
if(T)
{
ChangeLeftRight(T->lchild) ;
ChangeLeftRight(T->rchild) ;
temp = T->lchild ;
T->lchild = T->rchild ;
T->rchild = temp ;
}
}
// 层序遍历
void LevelOrder(BiTree T)
{
BiTree b ;
SqQueue Q ;
InitQueue(Q) ;
if(T)
{
EnQueue(Q , T) ;
while(!QueueEmpty(Q))
{
DeQueue(Q , b) ;
cout << b->data << " " ;
if(b->lchild != NULL) EnQueue(Q , b->lchild) ;
if(b->rchild != NULL) EnQueue(Q , b->rchild) ;
}
}
}
// 附加指令
// 复制
void Copy(BiTree T , BiTree &NewT)
{
if(T == NULL)
{
NewT = NULL ;
return ;
}
else
{
NewT = new BiTNode ;
NewT->data = T->data ;
Copy(T->lchild , NewT->lchild) ;
Copy(T->rchild , NewT->rchild) ;
}
}
// 先序非递归遍历
void PreOrder(BiTree T)
{
LinkStack S ;
InitStack(S) ;
BiTree p = T , q ;
while(p || !StackEmpty(S))
{
while(p)
{
cout << p->data << " " ;
Push(S , p) ;
p = p->lchild ;
}
if(!StackEmpty(S))
{
Pop(S , q) ;
p = q->rchild ;
}
}
}
//中序非递归遍历
void InOrder(BiTree T)
{
LinkStack S ;
InitStack(S) ;
BiTree p = T , q ;
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 ;
}
}
}
//16.判断两个二叉树是否完全相同
bool isSame(BiTree p, BiTree q)
{
//先进行判空
//两棵树均为空,则是相同的树
if (p == NULL && q == NULL) {
return true;
}
//只有一棵树是空树,则必不是相同的树
if (p == NULL || q == NULL) {
return false;
}
//其他情况,左子树相同,右子树相同,结点的值相同
return p->data == q->data && isSame(p->lchild, q->lchild) && isSame(p->rchild, q->rchild);
}
// 栈
// 初始化
Status InitStack(LinkStack &S)
{
S = NULL ;
return OK ;
}
// 判断栈是否为空
Status StackEmpty(LinkStack S)
{
if(S == NULL) return 1 ; //空
else return 0 ; //非空
}
// 入栈
Status Push(LinkStack &S , SElemType e)
{
LinkStack p ;
p = new StackNode ;//新建p存放插入元素
p->data = e , p->next = S ;
S = p ;
return OK ;
}
// 出栈
Status Pop(LinkStack &S , SElemType &e)
{
if(S == NULL) return ERROR ; //没有栈顶可删
LinkStack p = S ; //p临时保存栈顶,准备删除
e = S->data ; // 删除元素保存在e中
S = S->next ;
delete p ; //释放空间
return OK ;
}
// 队列
// 初始化
Status InitQueue(SqQueue &Q)
{
Q.base = new QElemType[MAXQSIZE] ;
if(!Q.base) return ERROR ;
Q.front = Q.rear = 0 ; // 开始为空 0
return OK ;
}
// 入队
Status EnQueue(SqQueue &Q , QElemType e)
{
if((Q.rear+1)%MAXQSIZE == Q.front) return ERROR ; // 已满
Q.base[Q.rear] = e ;
Q.rear = (Q.rear+1) % MAXQSIZE ;
return OK ;
}
// 出队
Status DeQueue(SqQueue &Q , QElemType &e)
{
if(Q.front == Q.rear) return ERROR ; // 空队列
e = Q.base[Q.front] ; // 传回到主函数
Q.front = (Q.front+1) % MAXQSIZE ;
return OK ;
}
// 判空
bool QueueEmpty(SqQueue Q)
{
if(Q.front == Q.rear) return true ;
else return false ;
}
三、com
#ifndef HEADER_H_INCLUDED
#define HEADER_H_INCLUDED
#define OK 1
#define ERROR 0
typedef int Status ;
typedef char TElemType ;
typedef struct BiTNode{
TElemType data ;
struct BiTNode *lchild , *rchild ;
}BiTNode , *BiTree ;
extern void CreateBiTree(BiTree &T) ;
extern void PreOrderTraverse(BiTree T) ;
extern void InOrderTraverse(BiTree T) ;
extern void PostOrderTraverse(BiTree T) ;
extern int Depth(BiTree T) ;
extern int NodeCount(BiTree T) ;
extern int LeafCount(BiTree T) ;
extern int CountSingleeNode(BiTree T) ;
extern int CountDoubleNode(BiTree T) ;
extern void ChangeLeftRight(BiTree &T) ;
extern void LevelOrder(BiTree T) ;
// 附加
extern void Copy(BiTree T , BiTree &NewT) ;
extern void PreOrder(BiTree T) ;
extern void InOrder(BiTree T) ;
extern void PostOrder(BiTree T) ;
bool isSame(BiTree p, BiTree q) ;//16.判断两个二叉树是否完全相同
// 队列
typedef BiTree QElemType ;
#define MAXQSIZE 5
typedef struct QNode{
QElemType *base ;
int front ;
int rear ;
}SqQueue;
// 栈
typedef BiTree SElemType ;
typedef struct StackNode{
SElemType data ;
struct StackNode *next ;
}StackNode , *LinkStack;
//
extern Status InitQueue(SqQueue &Q) ;
extern Status EnQueue(SqQueue &Q , QElemType e) ;
extern Status DeQueue(SqQueue &Q , QElemType &e) ;
extern bool QueueEmpty(SqQueue Q) ;
//
extern Status InitStack(LinkStack &S) ;
extern Status StackEmpty(LinkStack S) ;
extern Status Push(LinkStack &S , SElemType e) ;
extern Status Pop(LinkStack &S , SElemType &e) ;
#endif // HEADER_H_INCLUDED