5.二叉树综合运算

实验5-二叉树综合运算

实验目的

• 掌握链队列的应用；
• 掌握二叉树的存储方式和基本算法的实现；

代码

#include <iostream>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

typedef int Status; // Status是函数的类型
typedef char TElemType;

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

typedef BiNode *BiTree;

typedef BiTree QElemType;

//链队列的定义
struct QNode
{
	QElemType data;
	QNode *next;
};

typedef QNode *QueuePtr;

struct LinkQueue
{
	QueuePtr front, rear; // 队头、队尾指针
};

/***************以下为队列常用运算函数***************/
//初始化队列
Status InitQueue(LinkQueue &Q)
{ // 构造一个空队列Q
	Q.front = Q.rear = new QNode;
	Q.front->next = NULL;
	return OK;
}
//入队 算法3.17
Status EnQueue(LinkQueue &Q, QElemType e)
{ // 插入元素e为Q的新的队尾元素
	QNode *p = new QNode;
	p->data = e;
	p->next = NULL;
	Q.rear->next = p; //将新结点插入队尾
	Q.rear = p;		  //修改队尾指针
	return OK;
}
//判断队空
Status QueueEmpty(LinkQueue Q)
{ // 若Q为空队列，则返回TRUE，否则返回FALSE
	if (Q.front->next == NULL)
		return TRUE;
	else
		return FALSE;
}
//出队
Status DeQueue(LinkQueue &Q, QElemType &e)
{ // 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR
	if (Q.front == Q.rear)
		return ERROR;
	QNode *p = Q.front->next; //p指向队头指针
	e = p->data;
	Q.front->next = p->next; //修改头指针
	if (Q.rear == p)
		Q.rear = Q.front; //最后一个元素被删，队尾指针指向头结点
	delete p;
	return OK;
}

/***************以下为二叉树综合运算函数***************/
void InitBiTree(BiTree &T)
{ // 操作结果：构造空二叉树T
	T = NULL;
}

Status BiTreeEmpty(BiTree &T)
{ // 初始条件：二叉树T存在。操作结果：若T为空二叉树，则返回TRUE，否则FALSE
	if (T)
		return FALSE;
	else
		return TRUE;
}

//销毁二叉树
void DestroyBiTree(BiTree T)
{		   // 初始条件：二叉树T存在。操作结果：销毁二叉树T
	if (T) // 非空树
	{
		if (T->lchild)				  // 有左孩子
			DestroyBiTree(T->lchild); // 销毁左孩子子树
		if (T->rchild)				  // 有右孩子
			DestroyBiTree(T->rchild); // 销毁右孩子子树
		delete T;					  // 释放根结点
		T = NULL;					  // 空指针赋0
	}
}

//把指针指向给定元素
BiTree Point(BiTree T, TElemType s)
{ // 返回二叉树T中指向元素值为s的结点的指针。另加
	LinkQueue q;
	BiTree a;

	if (T) // 非空树
	{
		InitQueue(q);		   // 初始化队列
		EnQueue(q, T);		   // 根指针入队
		while (!QueueEmpty(q)) // 队不空
		{
			DeQueue(q, a); // 出队，队列元素赋给a
			if (a->data == s)
				return a;
			if (a->lchild)			   // 有左孩子
				EnQueue(q, a->lchild); // 入队左孩子
			if (a->rchild)			   // 有右孩子
				EnQueue(q, a->rchild); // 入队右孩子
		}
	}
	//  cout<<a->data<<endl;
	return NULL;
}

//给指定结点赋值
void Assign(BiTree p, TElemType value)
{ // 给p所指结点赋值为value
	p->data = value;
}
////////////////求某结果左孩子的值，如无则返回空////////////////
TElemType LeftChild(BiTree T, TElemType e)
{ // 初始条件：二叉树T存在，e是T中某个结点。操作结果：返回e的左孩子。若e无左孩子,则返回"空"
	BiTree a;
	if (T) // 非空树
	{
		a = Point(T, e);			// a是结点e的指针
		if (a && a->lchild)			// T中存在结点e且e存在左孩子
			return a->lchild->data; // 返回e的左孩子的值
	}
	return ' '; // 其余情况返回空
}

////////////////求某结果右孩子的值，如无则返回空////////////////
TElemType RightChild(BiTree T, TElemType e)
{ // 初始条件：二叉树T存在，e是T中某个结点。操作结果：返回e的右孩子。若e无右孩子,则返回"空"
	BiTree a;
	if (T) // 非空树
	{
		a = Point(T, e);			// a是结点e的指针
		if (a && a->rchild)			// T中存在结点e且e存在右孩子
			return a->rchild->data; // 返回e的右孩子的值
	}
	return ' '; // 其余情况返回空
}

////////////////利用队列求取某结点双亲的值,如找不能，则返回空////////////////
TElemType Parent(BiTree T, TElemType e)
{ // 初始条件：二叉树T存在，e是T中某个结点
	// 操作结果：若e是T的非根结点，则返回它的双亲，否则返回＂空＂
	LinkQueue q;
	QElemType a; //BiTree a;
	if (T)		 // 非空树
	{
		InitQueue(q);		   // 初始化队列
		EnQueue(q, T);		   // 树根指针入队
		while (!QueueEmpty(q)) // 队不空
		{
			DeQueue(q, a);																// 出队，队列元素赋给a
			if (a->lchild && a->lchild->data == e || a->rchild && a->rchild->data == e) // 找到e(是其左或右孩子)
				return a->data;															//返回e的双亲的值
			else																		// 没找到e，则入队其左右孩子指针(如果非空)
			{
				if (a->lchild)
					EnQueue(q, a->lchild);
				if (a->rchild)
					EnQueue(q, a->rchild);
			}
		}
	}
	return ' '; // 树空或没找到e
}

////////////////用算法5.3 先序遍历的顺序建立二叉链表////////////////
void CreateBiTree(BiTree &T)
{
	//按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T
	char ch;
	cin >> ch;
	if (ch == '#')
		T = NULL; //递归结束，建空树
	else
	{
		T = new BiNode;
		T->data = ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
}
////////////////用算法5.1 中序遍历////////////////
void InOrderTraverse(BiTree T)
{
	//中序遍历二叉树T的递归算法
	if (T)
	{
		InOrderTraverse(T->lchild);
		cout << T->data << "\t";
		InOrderTraverse(T->rchild);
	}
}
////////////////先序遍历////////////////
void PreOrderTraverse(BiTree T)
{
	//先序遍历二叉树T的递归算法
	if (T)
	{
		cout << T->data << "\t";
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}
////////////////后序遍历////////////////
void PostOrderTraverse(BiTree T)
{
	//后序遍历二叉树T的递归算法
	if (T)
	{
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		cout << T->data << "\t";
	}
}

//////////////求树深度////////////////////
int BiTreeDepth(BiTree T)
{
	int m, n, depth;
	if (T == NULL)
		return 0; //如果是空树，深度为0，递归结束

	m = BiTreeDepth(T->lchild);
	n = BiTreeDepth(T->rchild);
	depth = max(m, n) + 1;
	return depth;
}
//////////////求叶子数 /////////////////////
int LeafCount(BiTree T)
{
	if (T == NULL)
		return 0; //如果是空树，返回0
	if (T->lchild == NULL && T->rchild == NULL)
		return 1; //如果是叶子结点，返回1
	else
		return LeafCount(T->lchild) + LeafCount(T->rchild);
}
////////////////求结点数/////////////////////
int NodeCount(BiTree T)
{
	if (T == NULL)
		return 0;
	else
		return NodeCount(T->lchild) + NodeCount(T->rchild) + 1;
}
////////////////求根结点值//////////////////
TElemType Root(BiTree T)
{
	if (T)
		return T->data;
	else
		return ' ';
}

int main()
{
	BiTree T, p;
	TElemType e1, e2;
	int islelect;

	InitBiTree(T);
	cout << "------------------------------------------------------\n";
	printf("构造空二叉树后,树空否？%d(1:是 0:否)树的深度=%d\n", BiTreeEmpty(T), BiTreeDepth(T));
	e1 = Root(T);
	if (e1 != ' ')
		printf("二叉树的根为: %c\n", e1);
	else
		printf("树空，无根\n");
	cout << "------------------------------------------------------\n";

	printf("请先序输入二叉树(P121图5.10(b): ABC##DE#G##F###)\n");
	CreateBiTree(T);
	printf("建立二叉树后,树空否？%d(1:是 0:否)", BiTreeEmpty(T));

	e1 = Root(T);
	if (e1 != ' ')
		printf("二叉树的根为: %c\n", e1);
	else
		printf("树空，无根\n");
	cout << "------------------------------------------------------\n";
	cout << " 树的叶子数=" << LeafCount(T) << endl;
	cout << " 树的结点数=" << NodeCount(T) << endl;
	cout << " 树的叶深度=" << BiTreeDepth(T) << endl;

	printf("\n先序递归遍历二叉树:\n");
	PreOrderTraverse(T);
	printf("\n中序递归遍历二叉树:\n");
	InOrderTraverse(T);
	printf("\n后序递归遍历二叉树:\n");
	PostOrderTraverse(T);
	cout << "\n------------------------------------------------------\n";

	printf("\n请输入一个结点的值: ");
	cin >> e1;
	// cout<<e1;
	p = Point(T, e1); // p为e1的指针
	if (p)
		printf("结点的值为%c\n", p->data);
	else
		cout << "输入结点值错误！\n";
	cout << "\n------------------------------------------------------\n";

	printf("欲改变此结点的值，请输入新值: ");
	cin >> e2;
	Assign(p, e2);
	printf("\n先序递归遍历二叉树:");
	PreOrderTraverse(T);

	e1 = Parent(T, e2);
	if (e1 != ' ')
		printf("\n%c的双亲是%c", e2, e1);
	else
		printf("\n%c没有双亲\n", e2);

	e1 = LeftChild(T, e2);
	if (e1 != ' ')
		printf("\n%c的左孩子是%c\n", e2, e1);
	else
		printf("\n%c没有左孩子\n", e2);

	e1 = RightChild(T, e2);
	if (e1 != ' ')
		printf("\n%c的右孩子是%c\n", e2, e1);
	else
		printf("\n%c没有右孩子\n", e2);

	DestroyBiTree(T);
	system("pause");
	return 0;
}

运行截图

OOP 版

还没写。。。