Noeud* genererArbre(int nbNoeuds)
{
if (nbNoeuds > 0)
return creerNoeud((rand() % ('Z' - 'A' + 1)) + 'A',
genererArbre(nbNoeuds / 2),
genererArbre((nbNoeuds - 1) / 2));
return NULL;
}
NODE construireArbreHuffman(CARACTERE** tas, SIZE size)
{
NODE* former_node;
CARACTERE* current_caractere;
INDICE i;
SIZE list_size=0;
NODE_CHAIN CHAIN;
NODE_CHAIN* pCHAIN=&CHAIN;
CHAIN.chain_size=0;
NODE* left_son;
NODE* right_son;
for (i=size-1; ( (tas[i]->occurence!= 0) && (i != 0) ) ; i--)
{
NODE* current_node;
current_node=malloc(sizeof(NODE));
*current_node = creerNoeud(tas[i], 0, tas[i]->occurence, 0, NULL, NULL, NULL, NULL);
CHAIN.chain_size++;
if ( i == size-1 ) CHAIN.first_node = current_node;
else former_node->list_next=current_node;
former_node = current_node;
}
while ( CHAIN.chain_size >= 2 )
{
left_son=extractNodeFromChain(CHAIN, CHAIN.chain_size);
right_son=extractNodeFromChain(CHAIN, CHAIN.chain_size-1);
NODE* father;
father=malloc(sizeof(NODE));
*father = creerNoeud(NULL, 0, left_son->occurences_cumul + right_son->occurences_cumul, 0, NULL, left_son, right_son, NULL);
left_son->father=father;
right_son->father=father;
left_son->node_bit=0;
right_son->node_bit=1;
deleteNodeFromChain(pCHAIN, CHAIN.chain_size);
deleteNodeFromChain(pCHAIN, CHAIN.chain_size);
right_son->list_next=NULL;
left_son->list_next=NULL;
insertNodeOnChain(pCHAIN, father, CHAIN.chain_size);
}
return *CHAIN.first_node;
}
////////////////////////////////////////////////////////////////////////
///
/// @fn NoeudAbstrait* ArbreRendu::ajouterNouveauNoeud(const std::string& typeParent, const std::string& typeNouveauNoeud)
///
/// Cette fonction permet d'ajouter un nouveau noeud dans l'arbre de
/// rendu.
///
/// @param[in] typeParent : Le type du parent du nouveau noeud.
/// @param[in] typeNouveauNoeud : Le type du nouveau noeud.
///
/// @return Le noeud nouvellement créé.
///
////////////////////////////////////////////////////////////////////////
NoeudAbstrait* ArbreRendu::ajouterNouveauNoeud(
const std::string& typeParent,
const std::string& typeNouveauNoeud
)
{
NoeudAbstrait* parent = chercher(typeParent);
if (parent == 0) {
// Incapable de trouver le parent
return 0;
}
NoeudAbstrait* nouveauNoeud = creerNoeud(typeNouveauNoeud);
if (nouveauNoeud)
parent->ajouter(nouveauNoeud);
return nouveauNoeud;
}
int main( int argc, char * argv[] ){
noeud * b = creerNoeud_f( T_CST_REEL,4.5456456 );
noeud * c = creerNoeud_i( T_CST_ENTIER,85);
noeud * d = creerNoeud_i( T_CST_ENTIER,10 );
noeud * a = creerNoeud( T_AFFECT );
ajouterFrere( a,b );
ajouterFils( a,c );
ajouterFils( a,d );
afficherArbre(a);
printf("\n\n");
return 0;
}
////////////////////////////////////////////////////////////////////////
///
/// @fn bool BonusModifierSpawnPuck::Apply()
///
/// Applies the real effect on the node
/// returns false if the bonus finished the execution (no time to live)
/// in case it returns false, complete its execution
///
///
/// @return bool
///
////////////////////////////////////////////////////////////////////////
bool BonusModifierSpawnPuck::Apply()
{
if(mOwner)
{
auto field = mOwner->getField();
auto tree = field->getLogicTree();
if(tree)
{
auto mNewNode = tree->creerNoeud(RAZER_KEY_PUCK);
if(mNewNode)
{
mNewNode->setPosition(mOwner->getPosition());
field->addNode(mNewNode);
}
}
}
return false;
}
void main () {
typePile *pile;
char expr [TAILLEMAX];
int val;
char *ptexpr;
typeNoeud *feuille, *noeud, *droit, *gauche;
typeNoeud *racine;
pile = initpile (TAILLEPILE);
ptexpr = expr;
printf ("Entrer une expression postfixee\n");
fgets (expr, TAILLEMAX, stdin);
while (*ptexpr == ' ') ptexpr++;
while ( *ptexpr != '=' && *ptexpr != '\n' ) {
if (!isdigit (*ptexpr)) {
droit = depiler(pile);
gauche = depiler(pile);
noeud = creerNoeud (*ptexpr, gauche, droit);
empiler (pile, noeud);
ptexpr++;
} else {
sscanf (ptexpr, "%d", &val);
while (isdigit(*ptexpr)) ptexpr++;
feuille = creerFeuille (val);
empiler (pile, feuille);
}
while (*ptexpr == ' ') ptexpr++;
}
racine = depiler(pile);
printf ("\nExpression infixee : \n");
infixe (racine);
printf ("\n\n");
printf ("Expression prefixee : \n");
prefixe (racine);
printf ("\n\n");
printf ("Valeur de l'expression : %d\n", eval (racine));
}
int main (void) {
/* Declaration d'un objet pile */
typePile *pile;
// VARIABLES STD
char expr [TAILLEMAX];
int val;
char *ptexpr;
// VARIABLES DE L'ARBRE
typeNoeud *feuille, *noeud, *droit, *gauche;
typeNoeud *racine; // Pointe sur la racine de l'arbre
// INIT PILE
pile = initpile (TAILLEPILE);
// POINTEUR SUR L'EXPRESSION ENTREE
ptexpr = expr;
// DEMANDE EXPRESSION A L'UTILISATEUR
printf ("Entrer une expression postfixee\n");
fgets (expr, TAILLEMAX, stdin);
//-------------------------------------------------
// COMMENCER LE TRAITEMENT DE L'OPERATION POSTFIXEE
//-------------------------------------------------
// SAUTER LES BLANCS DU DEBUT
while (*ptexpr == ' ') ptexpr++;
/* L'expression se termine sur = ou \n */
while ( *ptexpr != '=' && *ptexpr != '\n' ) {
if (!isdigit (*ptexpr)) {
/* On a un operateur dans *ptexpr */
droit = depiler(pile); /* Depiler le fils droit */ //3
gauche = depiler(pile); /* Depiler le fils gauche */ //4
noeud = creerNoeud (*ptexpr, gauche, droit); //5
empiler (pile, noeud); /* Empiler le sous arbre */ //6
ptexpr++;
} else {
/* On a un operande dont la valeur est dans val */
sscanf (ptexpr, "%d", &val);
while (isdigit(*ptexpr)) ptexpr++; /* Sauter les digits */
feuille = creerFeuille (val); //1
empiler (pile, feuille); /* Empiler le noeud */ //2
}
while (*ptexpr == ' ') ptexpr++; /* Sauter les blancs */
}
racine = depiler(pile); // La racine est le dernier ÈlÈment de la pile
printf ("\nExpression infixee : \n");
infixe (racine); /* Parcours infixe de l'arbre obtenu */
printf ("\n\n");
printf ("Expression prefixee : \n");
prefixe (racine); /* Parcours prÈfixe de l'arbre obtenu */
printf ("\n\n");
printf ("Valeur de l'expression : %d\n", eval (racine));
system ("pause");
}
