/**
* 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().
**/
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);
}
}
}
/**
* 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().
**/
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);
}
}
}
void BTPreorder (tBTNodePtr RootPtr) {
/* ----------
** Prùchod stromem typu preorder implementovaný nerekurzivnì s vyu¾itím funkce
** Leftmost_Preorder a zásobníku ukazatelù. Zpracování jednoho uzlu stromu
** realizujte jako volání funkce BTWorkOut().
**/
tStackP s;
SInitP(&s);
Leftmost_Preorder(RootPtr, &s);
while(!SEmptyP(&s)){
RootPtr=STopPopP(&s);
Leftmost_Preorder(RootPtr->RPtr, &s);
}
}
/**
* Prechod stromom typu PreOrder implementovany nerekurzivne s vyuzitim funkcie
* Leftmost_Preorder a zasobniku ukazovatelov.
* @param RootPtr - koren stromu
**/
void BTPreorder(tBTNodePtr RootPtr)
{
if(RootPtr != NULL)
{
tBTNodePtr temp = NULL;
tStackP s;
SInitP(&s);
Leftmost_Preorder(RootPtr, &s);
while(!SEmptyP(&s))
{
temp = STopPopP(&s);
Leftmost_Preorder(temp->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);
}
}
}
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 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().
**/
if(!RootPtr)
return;
tStackP stack;
SInitP(&stack);
Leftmost_Inorder (RootPtr, &stack);
tBTNodePtr aux;
while(!SEmptyP(&stack))
{
aux = STopPopP(&stack);
BTWorkOut(aux);
Leftmost_Inorder (aux->RPtr, &stack);
}
}
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 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;
}