examTP-A_A12_2

Partie 1 :
1) Implémenter en C une liste doublement chaînée avec sentinelle permettant le stockage d'entiers.
Nous rappelons qu'une sentinelle est un nœud fictif dont i) le successeur est la tête de la liste et ii)
le prédécesseur la queue de la liste.
• Noeud* creerNoeud(int cle);
• void supprimerNoeud(Noeud* noeud);
• Liste* creerListeVide();
• void afficherContenuListe(Liste *liste);
• int listeVide(Liste *liste);
// → Renvoie 1 si la liste est vide, 0 sinon
• void viderListe(Liste *liste);
• void ajouterQueueListe(Liste *liste, int cle);
// → Ajoute un nœud en queue de liste.
• Noeud *obtenirDernierElement(Liste *liste);
// → Renvoie NULL si la liste est vide, le dernier
// nœud de la liste sinon.
• void supprimerListe(Liste *liste);
// → Vider la liste si nécessaire
2) Implémenter les fonctions nécessaires à faire de cette liste une pile.
• int depiler(Liste *pile);
• void empiler(int val);
3) Écrire une petite suite d'instruction permettant de testes les fonctions développées.
• Empiler 5 entiers aléatoires,
• Afficher la liste,
• Dépiler 2 entiers,
• Afficher la liste,

Partie 2 :
1) Implémenter la solution de cet exercice (utiliser la pile développée dans la partie 1) :
La notation polonaise est une façon d’écrire des expressions mathématiques sans devoir mettre de
parenthèses. Elle est utilisée par bon nombre de calculatrices. Par exemple, l’expression
5 ((9+8) (4 6) +7) s’écrit en notation polonaise inversée 5 9 8 + 4 6  7 +  . Implémenter un ∗ ∗ ∗ ∗ ∗ ∗
l'algorithme qui permet de trouver le résultat d’une expression en notation polonaise inversée. Les
opérations à considérer sont +, −, et /, agissant sur des entiers. ∗
• unsigned int lireExpression(char* expression)
// Rappel : le dernier élément d'une chaîne de
// de caractères en C est '\0'.
2) Tester votre fonction sur l'expression suivante :
EXPRESSION : 5 9 8 + 4 6 7 +  ∗ ∗ ∗
AFFICHAGE : 8 + 9 → 17 ; 6 * 4 → 24 ; 24 * 17 → 408 ; 7 + 408 → 415 ; 415 * 5 → 2075

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
typedef struct Noeud
{
    int cle;
    struct Noeud *pred;
    struct Noeud *succ;
}Noeud;

typedef struct Liste
{
    Noeud *sentinelle;
}Liste;

Noeud* creerNoeud(int cle)
{
    Noeud *p=malloc(sizeof(Noeud));
    p->cle=cle;
    return p;
}

void supprimerNoeud(Noeud* noeud)
{
    noeud->pred->succ=noeud->succ;
    noeud->succ->pred=noeud->pred;
    free(noeud);

}

Liste* creerListeVide()
{
    Liste *list;
    Noeud *cell;
    list=malloc(sizeof(Liste));
    cell=malloc(sizeof(Noeud));
    list->sentinelle=cell;
    cell->pred=cell;
    cell->succ=cell;
    return list;

}

void afficherContenuListe(Liste *liste)
{
    Noeud *c;
    c=liste->sentinelle->succ;
    while(c!=liste->sentinelle)
    {
        printf("%d ",c->cle);
        c=c->succ;
    }
}

int listeVide(Liste *liste)
{
    return(liste->sentinelle->pred==liste->sentinelle->succ);
}

void viderListe(Liste *liste)
{   Noeud *c;
    while(!listeVide(liste))
    {   c=liste->sentinelle->succ;
        supprimerNoeud(c);
    }
}

void ajouterQueueListe(Liste *liste, int cle)
{
    Noeud *c,*sentinelle;
    c=malloc(sizeof(Noeud));
    c->cle=cle;
    sentinelle=liste->sentinelle;
    c->pred=sentinelle->pred;
    c->succ=sentinelle;
    sentinelle->pred->succ=c;
    sentinelle->pred=c;
}

Noeud *obtenirDernierElement(Liste *liste)
{
    if(listeVide(liste))
        return NULL;
    else
        return liste->sentinelle->pred;
}

void supprimerListe(Liste *liste)
{
    viderListe(liste);
    free(liste);
}

int depiler(Liste *pile)
{
    Noeud *c=pile->sentinelle->pred;
    int a=c->cle;
    supprimerNoeud(c);
    return a;

}

int empiler(int val, Liste *pile)
{

  ajouterQueueListe(pile,val);
  return 1;
}

int calcul(char *ch)
{
    int nb1,nb2,nb,k=0;
    Liste *p=creerListeVide();
    while(ch[k]!='\0'){
        while(ch[k]>'0'&&ch[k]<='9'){
            nb=ch[k]-'0';
            empiler(nb,p);
            k++;
        }
        switch(ch[k]){
        case'+':{nb1=depiler(p);nb2=depiler(p);nb=nb1+nb2;printf("%d+%d->%d;\n",nb1,nb2,nb);break;}
        case'*':{nb1=depiler(p);nb2=depiler(p);nb=nb1*nb2;printf("%d*%d->%d;\n",nb1,nb2,nb);break;}
        case'-':{nb1=depiler(p);nb2=depiler(p);nb=nb1-nb2;printf("%d-%d->%d;\n",nb1,nb2,nb);break;}
        case'/':{nb1=depiler(p);nb2=depiler(p);nb=nb1/nb2;printf("%d/%d->%d;\n",nb1,nb2,nb);break;}
        }
        empiler(nb,p);
        k++;
    }
    depiler(p);
    return nb;
}
int main()
{   Liste *pile=creerListeVide();
    int i;
    srand(time(NULL));
    for(i=0;i<5;i++)
    empiler(rand()%100,pile);
    afficherContenuListe(pile);
    depiler(pile);
    depiler(pile);
    printf("\n");
    afficherContenuListe(pile);
    printf("\n");

    char s[20];
    printf("input your expression:\n");
    gets(s);
    int resultat=calcul(s);
    printf("%d",resultat);
    return 0;

}