/**
* Prechod stromom typu PostOrder implementovany nerekurzivne s vyuzitim funkcie
* Leftmost_Postorder, zasobniku ukazovatelov a zasobniku hotdnot typu bool.
* @param RootPtr - koren stromu
**/
void BTPostorder(tBTNodePtr RootPtr)
{
if(RootPtr != NULL)
{
tStackP sp;
tStackB sb;
int val;
tBTNodePtr temp = NULL;
SInitP(&sp);
SInitB(&sb);
Leftmost_Postorder(RootPtr, &sp, &sb);
while(!SEmptyP(&sp))
{
temp = STopPopP(&sp);
//SPushP(&sp, temp);
val = STopPopB(&sb);
if(val != FALSE)
{
SPushP(&sp, temp); // Potrebovali sme len Top
SPushB(&sb, FALSE);
Leftmost_Postorder(temp->RPtr, &sp, &sb);
}
else
{
//STopPopP(&sp);
BTWorkOut(temp);
}
}
}
}
void BTPostorder (tBTNodePtr RootPtr) {
/* -----------
** Prùchod stromem typu postorder implementovaný nerekurzivnì s vyu¾itím funkce
** Leftmost_Postorder, zásobníku ukazatelù a zásobníku hotdnot typu bool.
** Zpracování jednoho uzlu stromu realizujte jako volání funkce BTWorkOut().
**/
tStackB stackB;
tStackP stackP;
SInitB(&stackB);
SInitP(&stackP);
Leftmost_Postorder(RootPtr, &stackP, &stackB);
while (!SEmptyP(&stackP)) {
RootPtr = STopPopP(&stackP);
bool left = STopPopB(&stackB);
if (left) {
// Push back removed node
SPushP(&stackP, RootPtr);
SPushB(&stackB, FALSE);
Leftmost_Postorder(RootPtr->RPtr, &stackP, &stackB);
}
else {
BTWorkOut(RootPtr);
}
}
}
void BTPostorder (tBTNodePtr RootPtr) {
/* -----------
** Prùchod stromem typu postorder implementovaný nerekurzivnì s vyu¾itím funkce
** Leftmost_Postorder, zásobníku ukazatelù a zásobníku hotdnot typu bool.
** Zpracování jednoho uzlu stromu realizujte jako volání funkce BTWorkOut().
**/
if(!RootPtr)
return;
int l;
tStackP stack;
tStackB bstack;
SInitP(&stack);
SInitB(&bstack);
tBTNodePtr aux = RootPtr;
Leftmost_Postorder (aux, &stack, &bstack);
while(!SEmptyP(&stack))
{
aux = STopPopP(&stack);
SPushP(&stack,aux);
l = STopPopB(&bstack);
if(l)
{
SPushB(&bstack,FALSE);
Leftmost_Postorder(aux->RPtr, &stack, &bstack);
}
else
{
STopPopP(&stack);
BTWorkOut(aux);
}
}
}
/**
* Ide po lavej vetve podstromu, kym nenarazi na jeho najlavejsi uzol.
* Pri prechode PreOrder navstivene uzly spracujeme volanim funkcie BTWorkOut()
* a ukazovatele na ne si ulozime do zasobniku.
* @param ptr - ukazovatel na uzol stromu
* *Stack - zasobnik ukazovatelov
**/
void Leftmost_Preorder(tBTNodePtr ptr, tStackP *Stack)
{
while(ptr != NULL)
{
SPushP(Stack, ptr);
BTWorkOut(ptr);
ptr = ptr->LPtr;
}
}
void Leftmost_Preorder (tBTNodePtr ptr, tStackP *Stack) {
/* -----------------
** Jde po levì vìtvi podstromu, dokud nenarazí na jeho nejlevìj¹í uzel.
**
** Pøi prùchodu Preorder nav¹tívené uzly zpracujeme voláním funkce BTWorkOut()
** a ukazatele na nì is ulo¾íme do zásobníku.
**/
while (ptr != NULL) {
BTWorkOut(ptr);
SPushP(Stack, ptr);
ptr = ptr->LPtr;
}
}
void BTInorder (tBTNodePtr RootPtr) {
/* ---------
** Prùchod stromem typu inorder implementovaný nerekurzivnì s vyu¾itím funkce
** Leftmost_Inorder a zásobníku ukazatelù. Zpracování jednoho uzlu stromu
** realizujte jako volání funkce BTWorkOut().
**/
tStackP s;
SInitP(&s);
Leftmost_Inorder(RootPtr, &s);
while(!SEmptyP(&s)){
RootPtr=STopPopP(&s);
BTWorkOut(RootPtr);
Leftmost_Inorder(RootPtr->RPtr, &s);
}
}
/**
* Prechod stromom typu InOrder implementovany nerekurzivne s vyuzitim funkcie
* Leftmost_Inorder a zasobniku ukazovatelov.
* @param RootPtr - koren stromu
**/
void BTInorder(tBTNodePtr RootPtr)
{
if(RootPtr != NULL)
{
tStackP s;
tBTNodePtr temp = NULL;
SInitP(&s);
Leftmost_Inorder(RootPtr, &s);
while(!SEmptyP(&s))
{
temp = STopPopP(&s);
BTWorkOut(temp);
Leftmost_Inorder(temp->RPtr, &s);
}
}
}
