Programmation C

1- Représentation chaînée

struct cellule
{
int num, pr;
struct cellule *suiv;
};
typedef struct cellule cellule;
struct file
{
cellule *t,*q;
};
typedef struct file file;

2-

void enfiler (file *f, int n, int p)

{
cellule *aux;
aux=(cellule *) malloc (sizeof(cellule));

if(aux)
{
aux->num =n;
aux->pr=p;
aux->suiv=NULL;
if( f->t==NULL)
{
f->t=aux;
f->q=aux;
}
else
{
f->q->suiv=aux;
f->q=aux;
}
}
}

void defiler(file *f, int *n, int *p)

{
cellule * aux;
if(! f->t)
printf("file vide\n");
else
{
*n=(f->t)->num;
*p=f->t->pr;
if(f->t==f->q)
{
free(f->t);
f->t=NULL;
f->q=NULL;
}
else
{
aux=f->t;
f->t=aux->suiv;
free(aux);
}
}
}

3-

int compte(file *f, int p)

{
int nbre=0, n,num, pr;
if( !Est-vide(f))
{
n=f->t->num;
do
{
defiler(f,&num,&pr);
if(pr==p) nbre++;
enfiler(f,num,pr);
}while(f->t->num!=n);
}
return nbre;
}

4-

void traiter(file *f)

{
int pr=3, i,p,nb,n;
while(pr)
{
nb=compte(f,pr);
i=1;
while(i<=nb)
{
defiler(f,&n,&p);

if(p==pr)
{ traiter_dossier(n);
printf("dossier de numero %d traité -\n", n);
i++;
}
else
{
enfiler(f,n,p);
}
}
pr--;

}
}

5-
5.1 Représentation chaînée d’une pile
typedef cellule * pile;

5.2
void empiler(pile *p,int e, int pri)
{
cellule *aux;
aux=(cellule *) malloc (sizeof(cellule));

if(aux)
{
aux->num=e;
aux->pr=pri;
aux->suiv=*p;
*p=aux;
}
}

void depiler(pile *p, int*e, int *pri)

{
cellule *aux;
if (*p)
{
aux=*p;
*e=aux->num;
*pri=aux->pr;
*p=aux->suiv;
free(aux);
 }
}

5.3-
void traiterDossiers(file *f)
{
int n, p;
pile pl;
pileVide(&pl);
traiter(f);
while(f->t)
{
defiler(f,&n,&p);
empiler(&pl,n,p);
}
while (pl)
{
depiler(&pl,&n,&p);
traiter-dossier(n);
}
}

Exercice 1

1- Voir la représentation chaînée d’un arbre binaire dans le cours

2- Fonction max(A : Arbre) : Arbre
Debut
Si A=Nil alors retourner(Nil)
Sinon Si A^.d=Nil alors retourner (A)
Sinon retourner (max(A^.d))
Fsi
Fsi
Fin

3- Voir l’ajout d’un nœud aux feuilles dans un ABR

4- Procedure Affiche( DON A : Arbre)
Debut

Si A <> Nil alors

Affiche(A^.d)
Ecrire (A^.val)
Affiche(A^.g)
Fsi
Fin

5-
Le principe de l’algorithme est le suivant :
Il faut tout d’abord trouver le nœud p dont l’adresse est passée en paramètre ;
Une fois le nœud p trouvé, il faut parcourir les sous-arbres gauche et droit de p de et à chaque fois insérer le nœud courant
dans la liste.

Nœud=struct
val : entier
suiv : ^nœud
fin
Liste = ^nœud

Procedure construire(A : Arbre, p : Arbre, L : Liste)

Debut

Si A <> Nil alors

Si (A=p) alors
Insere-liste(L, p^.d)
Insere-liste(L,p^.g)
Sinon si (A^.val<p^.val) alors
construire(A^.g,p,L)
sinon
construire(A^.d,p,L)
Fsi
 Fsi
Fsi
Fin

6-
Procedure rotation-droite( A : Arbre, p : Arbre)
Var
q : Arbre
Debut
q <- père(A,p) procedure de recherche du père d’un nœud p dans un arbre de racine A (voir TD)

si q^.g=p alors
rotation(p)
q^.g ← p
sinon

rotation(p)
q^.d ← p
fsi
fin

procedure rotation (DONRES A: Arbre)

var
aux : Arbre
debut
si A<> nil alors

aux ← A
A ← aux^.g
Aux^.g ← A^.d
A^.d ← aux
Fsi
Fin