Example #1
0
File: c402.c Project: klimko/IAL
/**
 * 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))));
  }
}
Example #2
0
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);
        }
    }
}
Example #3
0
File: c402.c Project: klimko/IAL
/**
 * 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);
      }
    }
  }
}
Example #4
0
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);
	  	}
	}
	
}
Example #5
0
File: c402.c Project: pavelfryz/fit
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);
  }
}
Example #6
0
File: c402.c Project: klimko/IAL
/**
 * 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);
    }
  }
}
Example #7
0
File: c402.c Project: klimko/IAL
/**
 * 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);
    }
  }
}
Example #8
0
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;
}
Example #9
0
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);
	}
	
}
Example #10
0
File: c402.c Project: pavelfryz/fit
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);
    }
  }
}
Example #11
0
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;
}