/**
* 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);
}
}
}
/**
* Zrusi vsetky uzly stromu a korektne uvolni nimi zabranou pamat.
* @param *RootPtr - koren uzol
**/
void BTDisposeTree(tBTNodePtr *RootPtr)
{
if((*RootPtr) != NULL)
{
tStackP s;
tBTNodePtr temp;
SInitP(&s);
do
{
if((*RootPtr) == NULL)
{
if(!SEmptyP(&s))
{
(*RootPtr) = STopPopP(&s);
}
}
else
{
if((*RootPtr)->RPtr != NULL)
{
SPushP(&s, (*RootPtr)->RPtr);
}
temp = (*RootPtr);
(*RootPtr) = (*RootPtr)->LPtr;
free(temp);
}
} while(!(((*RootPtr) == NULL) && (SEmptyP(&s))));
}
}
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 InOrder ukladame ukazovatele na vsetky navstivene uzly do
* zasobniku.
* @param ptr - ukazovatel na uzol stromu
* @param *Stack - zasobnik ukazovatelov
**/
void Leftmost_Inorder(tBTNodePtr ptr, tStackP *Stack)
{
while(ptr != NULL)
{
SPushP(Stack, ptr);
ptr = ptr->LPtr;
}
}
/**
* Ide po lavej vetve podstromu, kym nenarazi na jeho nejlavejsi uzol.
* Pri prechode PostOrder ukladame ukazovatele na navstivene uzly do zasobniku
* a sucasne do zasobniku bool hodnot ukladame informaciu, ci bol uzol
* navstiveny poprvykrat, t.j. ze sa este nema spracovavat.
* @param ptr - ukazovatel na uzol stromu
* @param *StackP - zasobnik ukazovatelov na uzly stromu
* @param *StackB - zasobnik bool hodnot
**/
void Leftmost_Postorder(tBTNodePtr ptr, tStackP *StackP, tStackB *StackB)
{
while(ptr != NULL)
{
SPushP(StackP, ptr);
SPushB(StackB, TRUE);
ptr = ptr->LPtr;
}
}
void Leftmost_Inorder(tBTNodePtr ptr, tStackP *Stack) {
/* ----------------
** Jde po levì vìtvi podstromu, dokud nenarazí na jeho nejlevìj¹í uzel.
**
** Pøi prùchodu Inorder ukládáme ukazatele na v¹echny nav¹tívené uzly do
** zásobníku.
**/
while (ptr != NULL) {
SPushP(Stack, ptr);
ptr = ptr->LPtr;
}
}
void BTDisposeTree (tBTNodePtr *RootPtr) {
/* -------------
** Zru¹í v¹echny uzly stromu a korektnì uvolní jimi zabranou pamì».
**
** Funkci implementujte nerekurzivnì s vyu¾itím zásobníku ukazatelù.
**/
tStackP stack;
SInitP(&stack);
SPushP(&stack,*RootPtr);
while(!SEmptyP(&stack))
{
tBTNodePtr aux = STopPopP(&stack);
if(!aux)
continue;
SPushP(&stack,aux->LPtr);
SPushP(&stack,aux->RPtr);
free(aux);
}
*RootPtr=NULL;
}
void BTDisposeTree (tBTNodePtr *RootPtr) {
/* -------------
** Zru¹í v¹echny uzly stromu a korektnì uvolní jimi zabranou pamì».
**
** Funkci implementujte nerekurzivnì s vyu¾itím zásobníku ukazatelù.
**/
tStackP s;
SInitP(&s);
SPushP(&s,*RootPtr); //vlozeni vrcholu na zasobnik
while(!SEmptyP(&s)){
*RootPtr=STopPopP(&s);
//uvolnovani leve diagonaly, pridavani pravych synu na zasobnik
while(*RootPtr!=NULL){
tBTNodePtr ptr=(*RootPtr);
if((*RootPtr)->RPtr!=NULL)
SPushP(&s,(*RootPtr)->RPtr);
*RootPtr=(*RootPtr)->LPtr;
free(ptr);
}
}
}
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 Leftmost_Postorder (tBTNodePtr ptr, tStackP *StackP, tStackB *StackB) {
/* --------
** Jde po levì vìtvi podstromu, dokud nenarazí na jeho nejlevìj¹í uzel.
**
** Pøi prùchodu Postorder ukládáme ukazatele na nav¹tívené uzly do zásobníku
** a souèasnì do zásobníku bool hodnot ukládáme informaci, zda byl uzel
** nav¹tíven poprvé a ¾e se tedy je¹tì nemá zpracovávat.
**/
while (ptr != NULL) {
SPushP(StackP, ptr);
SPushB(StackB, TRUE);
ptr = ptr->LPtr;
}
}
void BTDisposeTree (tBTNodePtr *RootPtr) {
/* -------------
** Zru¹í v¹echny uzly stromu a korektnì uvolní jimi zabranou pamì».
**
** Funkci implementujte nerekurzivnì s vyu¾itím zásobníku ukazatelù.
**/
tStackP stack;
SInitP(&stack);
tBTNodePtr node = *RootPtr, nextNode = NULL;
while (node != NULL) {
// Traversing logic
if (node->LPtr != NULL) {
nextNode = node->LPtr;
// Next node already set so put this node on stack
if (node->RPtr != NULL)
SPushP(&stack, node->RPtr);
}
else if (node->RPtr != NULL)
nextNode = node->RPtr;
else {
// Test if there's anything left to free
if (SEmptyP(&stack))
nextNode = NULL;
else
nextNode = STopPopP(&stack);
}
// Free node currently processed
free(node);
node = nextNode;
}
*RootPtr = NULL;
}