数据结构之二叉树遍历与AllPathPrint(队列)

#include<iostream>
#include<malloc.h>
using namespace std;
typedef char ElemType;
typedef struct BTNode
{
	ElemType data;
	struct BTNode *pLchild;
	struct BTNode *pRchild;
}BTNode, *pBTNode;

void Visit(pBTNode pT)
{
	cout << pT->data << " ";
}

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

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 PreOrder(pBTNode pT)//先序遍历
{
	if (pT)
	{
		Visit(pT);
		PreOrder(pT->pLchild);
		PreOrder(pT->pRchild);
	}
}

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

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

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);
	}
}




#define SIZEADD 10
#define STACKSIZE 20
typedef struct
{
	pBTNode *pBottom;
	pBTNode *pTop;
	int Stacksize;
}Stack;

void InitStack(Stack &S)
{
	S.pBottom = new pBTNode[STACKSIZE];
	S.pTop = S.pBottom;
	S.Stacksize = STACKSIZE;
}

void DestroyStack(Stack &S)//数组中的每个元素都是指针，暂时未解决
{
	delete[]S.pBottom;
	S.pBottom = NULL;
	S.pTop = NULL;
	S.Stacksize = 0;
}

void ClearStack(Stack &S)
{
	S.pTop = S.pBottom;
}

bool StackEmpty(Stack S)
{
	if (S.pBottom == S.pTop)

		return true;
	else
		return false;
}

int StackLength(Stack S)
{
	return (S.pTop - S.pBottom);
}

void Push(Stack &S, pBTNode pT)
{
	if (S.pTop - S.pBottom >= S.Stacksize)
	{
		S.pBottom = (pBTNode*)realloc(S.pBottom, (S.Stacksize + SIZEADD)*sizeof(pBTNode));
		S.pTop = S.pBottom + S.Stacksize;
		S.Stacksize += SIZEADD;
	}
	*S.pTop++ = pT;
	return;
}

void Pop(Stack &S, pBTNode &pT)
{
	if (StackEmpty(S))
		return;
	pT = *--S.pTop;
}

bool GetTop(Stack S, pBTNode &pT)
{
	if (StackEmpty(S))
		return false;
	pT = *(S.pTop - 1);
	return true;
}

void TraverseDe(Stack S)
{
	pBTNode *pp = S.pTop;
	if (StackEmpty(S))
		return;
	while (pp > S.pBottom)
	{
		--pp;
		Visit(*pp);
	}
	cout << endl;
	return;
}

void TraverseAs(Stack S)
{
	pBTNode* pp = S.pBottom;
	if (StackEmpty(S))
		return;
	while (pp<S.pTop)
	{
		Visit(*pp);
		++pp;
	}
	cout << endl;
	return;
}



void PreOrderT(pBTNode pT)
{
	Stack S;
	pBTNode p;
	InitStack(S);
	Push(S, pT);
	while (!StackEmpty(S))
	{
		Pop(S, p); Visit(p);
		if (p->pRchild) Push(S, p->pRchild);//注意:先右
		if (p->pLchild) Push(S, p->pLchild);//注意:后左
	}
}

void InOrderT(pBTNode pT)
{//首先寻找当前树的第一个要访问的结点(该结点一定无左子树)并访问它
 //其次判断该结点是否有右子树
      //如果没有,则出栈访问栈顶元素
	  //否则,显然是有右子树,那么我就对其右子树重复上述过程
	Stack S;
	pBTNode p = pT;
	InitStack(S);
	while (p || !StackEmpty(S))
	{
		if (p)
		{
			Push(S, p); p = p->pLchild;//寻找当前树的第一个访问的结点
		}
		else
		{
			Pop(S, p); Visit(p);//访问当前结点之后,判断当前结点是否有右子树
			p = p->pRchild;
		}
	}
}

void InOrderT1(pBTNode pT)//有错误，待解决
{
	Stack S;
	pBTNode p = pT;
	InitStack(S);
	Push(S, pT);
	while (!StackEmpty(S))
	{
		while (GetTop(S, p) && p)//找第一个遍历的结点(也就是有根结点向左走到头)
		{
			Push(S, p->pLchild);
		}
		Pop(S, p);//空指针退栈
		if (!StackEmpty(S))
		{
			Pop(S, p); Visit(p);
			Push(S, p->pRchild);
		}
	}
}

void AllPathPrint(pBTNode pT, Stack &S)
{
	if (pT)
	{
		Push(S, pT);
		if (!(pT->pLchild) && !(pT->pRchild))
			TraverseAs(S);
		else
		{
			AllPathPrint(pT->pLchild, S);
			AllPathPrint(pT->pRchild, S);
		}
		Pop(S, pT);
	}
}

int main(void)
{
	pBTNode pT = NULL;
	CreateBT(pT);//ABD##E##CF##G##
	PreOrder(pT);
	cout << endl;
	PreOrderT(pT);
	cout << endl;
	InOrder(pT);
	cout << endl;
	InOrderT(pT);
	cout << endl;
	InOrderT1(pT);
	cout << endl;
	Stack S;
	InitStack(S);
	AllPathPrint(pT, S);
	return 0;
}