数据结构之二叉树(递归)-CSDN博客

本文链接：https://blog.csdn.net/hgeternal/article/details/39498387
#include<iostream>
using namespace std;
typedef char ElemType;
typedef struct BTNode
{
	ElemType data;
	struct BTNode *pLchild;
	struct BTNode *pRchild;
}BTNode, *pBTNode;

void Visit(ElemType e)
{
	cout << e;
}

void CreateBT(pBTNode &pT)//先序思想创建二叉树
{
	ElemType ch;
	cin >> ch;
	if (ch == '#')
		pT = NULL;
	else
	{
		pT = new BTNode;
		pT->data = ch;
		CreateBT(pT->pLchild);
		CreateBT(pT->pRchild);
	}
}

void DestroyBT(pBTNode &pT)//后序思想销毁二叉树
{
	if (pT)
	{
		DestroyBT(pT->pLchild);
		DestroyBT(pT->pRchild);
		delete pT;
		pT = NULL;
	}
}

void CopyBT(pBTNode &pT1, pBTNode pT2)
{
	if (!pT2)
		pT1 = pT2;
	else
	{
		pT1 = new BTNode;
		pT1->data = pT2->data;
		CopyBT(pT1->pLchild, pT2->pLchild);
		CopyBT(pT1->pRchild, pT2->pRchild);
	}
}

void PreOrder(pBTNode pT)//先序遍历
{
	if (pT)
	{
		Visit(pT->data);
		PreOrder(pT->pLchild);
		PreOrder(pT->pRchild);
	}
}

void InOrder(pBTNode pT)//中序遍历
{
	if (pT)
	{
		InOrder(pT->pLchild);
		Visit(pT->data);
		InOrder(pT->pRchild);
	}
}

void PostOrder(pBTNode pT)//后序遍历
{
	if (pT)
	{
		PostOrder(pT->pLchild);
		PostOrder(pT->pRchild);
		Visit(pT->data);
	}
}

void PrintLeaf(pBTNode pT)//先序思想输出所有叶子节点
{
	if (pT)
	{
		if (!(pT->pLchild) && !(pT->pRchild))
			Visit(pT->data);
		PrintLeaf(pT->pLchild);
		PrintLeaf(pT->pRchild);
	}
}

void CountLeaf(pBTNode pT, int &count)//先序思想获取叶子节点个数
{
	if (pT)
	{
		if (!(pT->pLchild) && !(pT->pRchild))
			++count;
		CountLeaf(pT->pLchild, count);
		CountLeaf(pT->pRchild, count);
	}
}

bool BothLike(pBTNode pT1, pBTNode pT2)
{
	if (!pT1&&!pT2)
		return true;
	else if (!pT1 || !pT2)
		return false;
	else
		return (BothLike(pT1->pLchild, pT2->pLchild) && BothLike(pT1->pRchild, pT2->pRchild));
}

bool BothEqual(pBTNode pT1, pBTNode pT2)
{
	if (!pT1&&!pT2)
		return true;
	else if (!pT1 || !pT2||pT1->data != pT2->data)
		return false;
	else
		return (BothEqual(pT1->pLchild, pT2->pRchild) && BothEqual(pT1->pRchild, pT2->pRchild));
}

bool BTEmpty(pBTNode pT)
{
	if (pT)
		return false;
	else
		return true;
}

int BTDepth(pBTNode pT)//先序思想计算树的深度
{
	int depthL = 0; 
	int depthR = 0;
	if (!pT)
		return 0;
	else
	{
		depthL = BTDepth(pT->pLchild);
		depthR = BTDepth(pT->pRchild);
		return (depthL > depthR ? depthL + 1 : depthR + 1);
	}
}

bool IsBalenceBT(pBTNode pT)//待检
{
	if (!pT)
		return false;
	int DepthL = BTDepth(pT->pLchild);
	int DepthR = BTDepth(pT->pRchild);
	if (DepthL == DepthR || DepthL - DepthR == 1 || DepthR - DepthL == 1)
	{
		if (IsBalenceBT(pT->pLchild) && IsBalenceBT(pT->pRchild))
			return true;
		else
			return false;
	}
	else
		return false;
}

void GetMirror(pBTNode *ppT)
{
	if (*ppT)
	{
		pBTNode p = (*ppT)->pLchild;
		(*ppT)->pLchild = (*ppT)->pRchild;
		(*ppT)->pRchild = p;
		GetMirror(&((*ppT)->pLchild));
		GetMirror(&((*ppT)->pRchild));
	}
}

ElemType GetRoot(pBTNode pT)
{
	if (!pT)
		return NULL;
	else
		return pT->data;
}

ElemType GetValue(pBTNode p)
{
	return p->data;
}

void Assgin(pBTNode p, ElemType e)
{
	p->data = e;
}




int main(void)
{
	pBTNode pT = NULL, pT1 = NULL; int count = 0;
	CreateBT(pT);//输入 ABC##D##EF##G##
	CopyBT(pT1, pT);
	PreOrder(pT1);
	cout << endl;
	InOrder(pT);
	cout << endl;
	PostOrder(pT);
	cout << endl;
	PrintLeaf(pT);
	cout << endl;
	CountLeaf(pT, count);
	cout << count << endl;
	if (BTEmpty(pT))
		cout << "Indeed Empty!" << endl;
	else
		cout << "Not Empty!" << endl;
	cout << BTDepth(pT) << endl;
	CreateBT(pT1);//输入abc##d##ef##g##
	if (BothLike(pT, pT1))
		cout << "Indeed Like!" << endl;
	else
		cout << "Not Like!" << endl;
	return(0);
}