#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);
}
}
void PrintLeaf(pBTNode pT)//先序思想输出所有叶子节点
{
if (pT)
{
if (!(pT->pLchild) && !(pT->pRchild))
Visit(pT);
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
{
BothLike(pT1->pLchild, pT2->pLchild);
BothLike(pT1->pRchild, pT2->pRchild);
return true;
}
}
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);
}
}
return;
}
int main(void)
{
pBTNode pT = NULL;
CreateBT(pT);//ABC##D##EF##G##
PreOrder(pT);
cout << endl;
PreOrderT(pT);
cout << endl;
InOrder(pT);
cout << endl;
InOrderT(pT);
cout << endl;
InOrderT1(pT);
cout << endl;
return 0;
}
数据结构之二叉树(附栈实现先序,中序非递归遍历)
最新推荐文章于 2021-09-28 16:30:49 发布