5.1~5.5二叉树的基本操作

代码实现

#pragma once
#include <iostream>

using namespace std;


//二叉树的二叉链表存储表示
typedef struct BiTNode
{
	char data;
	struct BiTNode* lchild, * rchild;
}BiTNode,*BiTree;

//顺序栈的存储结构
#define MAXSIZE 100
typedef struct
{
	BiTree* base;
	BiTree* top;
	int stacksize;
}SqStack;


//初始化 构造空二叉树
void InitBiTree(BiTree& T);
//构造二叉树
void createBiTree(BiTree& T);
//递归销毁一棵二叉树 
void destroyBiTree(BiTree& T);
//清空二叉树
void ClearBiTree(BiTree& T);
//判空
bool BiTreeEmpty(BiTree T);
//先序递归遍历二叉树（根左右）
void PreOrder(BiTree T);
//中序递归遍历二叉树（左根右）
void InOrder(BiTree T);
//后序递归遍历二叉树（左右根）
void PostOrder(BiTree T);
//中序遍历的非递归算法
void InOrderTraverse(BiTree T);

//顺序栈的初始化
void InitStack(SqStack& S);
//顺序栈的判空
bool StackEmpty(SqStack S);

//顺序栈的入栈
void Push(SqStack& S, BiTree e);
//顺序栈的出栈
void Pop(SqStack& S, BiTree& e);
//二叉树的复制
void copy(BiTree T, BiTree& NewT);
//计算二叉树的深度
int Depth(BiTree T);
//计算二叉树中节点的个数
int NodeCount(BiTree T);

int main()
{
	BiTree T;
	
	InitBiTree(T);
	cout << "按先序次序输入二叉树中结点的值" << endl;
	createBiTree(T);
	//先序遍历
	cout << "先序遍历:" << endl;
	PreOrder(T);
	cout << endl;

	//中序遍历
	cout << "中序遍历:" << endl;
	InOrder(T);
	cout << endl;


	//后序遍历
	cout << "中序遍历:" << endl;
	PostOrder(T);
	cout << endl;


	//中序遍历的非递归算法
	cout << "中序遍历的非递归算法:" << endl;
	InOrderTraverse(T);
	cout << endl;

	cout << "二叉树的复制" << endl;
	//二叉树的复制
	BiTree NewT;
	copy(T, NewT);
	//先序遍历
	cout << "先序遍历:" << endl;
	PreOrder(NewT);
	cout << endl;

	//计算二叉树的深度
	int res = Depth(T);
	cout << "二叉树T的深度:" << res << endl;

	//计算二叉树中节点的个数
	int num = NodeCount(T);
	cout<<"二叉树T节点的个数:"<<num<<endl;
	system("pause");
	return 0;
}


//初始化 构造空二叉树
void InitBiTree(BiTree& T)
{
	T = NULL;
}


//构造二叉树
//按先序次序输入二叉树中结点的值（一个字符）
//＃字符表示空树，结束输入

void createBiTree(BiTree& T)
{
	char data;
	cin >> data;

	if (data != '#')
	{
		// 生成根节点
		T = new BiTNode;
		T->data = data;
		// 构造左子树
		createBiTree(T->lchild);
		// 构造左子树
		createBiTree(T->rchild);
	}
	else
	{
		T = NULL;
	}

}


//递归销毁一棵二叉树 
//传入根节点 
void destroyBiTree(BiTree& T)
{
	if (T != NULL)
	{
		destroyBiTree(T->lchild);
		destroyBiTree(T->rchild);
		delete T;
	}
}
//清空二叉树
void ClearBiTree(BiTree& T)
{
	if (T != NULL)
	{

		ClearBiTree(T->lchild);
		if ((T)->rchild)
			ClearBiTree(T->rchild);
		delete T;
		T = NULL;
	}
}
//判空
bool BiTreeEmpty(BiTree T)
{
	if (T)
	{
		return false;
	}
	else
	{
		return true;
	}
}

//先序递归遍历二叉树（根左右）
void PreOrder(BiTree T)
{
	if (T != NULL)
	{
		// 访问根结点
		cout << T->data << " ";
		// 遍历左子树
		PreOrder(T->lchild);
		// 遍历右子树
		PreOrder(T->rchild);
	}
}

//中序递归遍历二叉树（左根右）
void InOrder(BiTree T)
{
	if (T != NULL)
	{
		// 中序遍历左子树
		InOrder(T->lchild);
		// 访问根结点
		cout << T->data << " ";
		// 中序遍历右子树
		InOrder(T->rchild);
	}
}

//后序递归遍历二叉树（左右根）
void PostOrder(BiTree T)
{
	if (T != NULL)
	{
		// 后序遍历左子树
		PostOrder(T->lchild);
		// 后序遍历右子树
		PostOrder(T->rchild);
		// 访问根结点
		cout << T->data << " ";
	}
}

//中序遍历的非递归算法
void InOrderTraverse(BiTree T)
{
	SqStack S;
	InitStack(S);

	BiTNode* p = T;
	BiTNode* 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;
		}
	}
}




//顺序栈的初始化
void InitStack(SqStack& S) 
{         
	//构造一个空栈
	S.base = new BiTree[MAXSIZE];
	//存储分配失败
	if (!S.base)
	{
		exit(1);
	}      
	//栈顶指针等于栈底指针
	S.top = S.base;   
	//栈的最大容量
	S.stacksize = MAXSIZE;
}

//顺序栈的判空
bool StackEmpty(SqStack S)
{
	if (S.top == S.base)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//顺序栈的入栈
void Push(SqStack& S, BiTree e) 
{
	//栈满
	if (S.top - S.base == S.stacksize)
	{
		cout << "栈满" << endl;
		exit(0);
	}
	//插入栈顶元素	
	*(S.top)= e;
	//栈顶指针指向下一个
	*S.top++;
}

//顺序栈的出栈
void Pop(SqStack& S, BiTree &e)
 {
	
	if (StackEmpty(S))
	{
		cout << "栈空" << endl;
		exit(0);
	}
	S.top--;
	e =*(S.top);
}

//二叉树的复制
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);
	}
}

//计算二叉树的深度
int Depth(BiTree T)
{
	if (T == NULL)
	{
		return 0;
	}
	else
	{
		//递归计算左子树的深度
		int m = Depth(T->lchild);
		//递归计算右子树的深度
		int n = Depth(T->rchild);
		return (m > n) ? (m + 1) : (n + 1);
	}
}

//计算二叉树中节点的个数
int NodeCount(BiTree T)
{
	if (T == NULL)
	{
		return 0;
	}
	else
	{
		int m = NodeCount(T->lchild);
		int n = NodeCount(T->rchild);
		return (m + n + 1);
	}
}

运行结果