//************************************************
//Université Moulay Ismail
//Faculté des Sciences - Meknès 
//Département d'Informatique 
//*************************************************
// TD-TP sur les Piles Statiques - SMA-S4-Info4
//Corrigé du problème numéro 2
//*************************************************

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
# define max 20
//  Définition de la  structure pile
typedef struct pile {
    int  t[max];
    int sommet;
}pile;

// Début des fonctions utilisées par la fonction itérative  
//  Création d’une pile vide pile//
typedef struct pile pile;

pile creer_pile(){
pile pp;
pp.sommet=-1;
return pp;
}	// fin de la fonction creer_pile 
// Tester si la pile est vide

int pile_vide(pile * pp){
return ((pp->sommet)==-1);
}	// fin de la fonction pile_vide 
// Ajout d’un entier dans la pile

void empiler(pile * pp, int e) {
    if (pp->sommet<max-1)  {
            	pp->sommet++;
            	pp->t[pp->sommet]=e;
            }
   else  {  printf("Pile Pleine") ;
  exit(0) ; }
return; } 	// Fin de la fonction empiler 
// Fonction qui supprime un entier de la pile 

int depiler(pile * pp){
    int e;
if (!pile_vide(pp)) {
     e= pp->t[pp->sommet];
    pp->sommet--; } 
return e; }   // Fin de la fonction dépiler 

// Fonction itérative qui fait appel à la pile, donc aux fonction empiler et dépiler 
// pour convertir un entier positif en son équivalent binaire 
    void  Bin_itera(int n, pile * pp) {
               int i=n;
  	while(i) {
         empiler(pp, i%2);  // empiler les restes de la division euclidienne tant que les quotients sont non nuls 
        		 i=i/2;
 		 } 
	while( !pile_vide(pp))  {
		printf("%d", depiler(pp)) ;} //affichage de la représentation binaire 
	return; }  	// Fin de la fonction Bin_Itera
// Fin des fonction utilisées par la fonction itérative  

// Fonction récursive convertissant un entier positif en sa représentation binaire 
void Bin_rec(int a)
{
    int reste;
    if(a>0)
    {
        reste=a%2;
        Bin_rec(a/2);
    printf("%d",reste);
    }
return ; } // Fin de la fonction Bin_rec 

//  Programme principal convertissant un entier positif en sa représentation binaire de deux façons :
// D’une façon itérative en appelant la fonction Bin_itera
// D’une façon récursive en appelant la fonction Bin_rec
int  main() {
     	 int n;
     	 pile  p= creer_pile();  // initialisation de la pile à vide 
  	     printf("Saisir au clavier un entier positif :  !\t");
    	scanf("%d",&n);
       // appel de la fonction récursive  
    	printf("Equivalent  de n= %d en base binaire  avec la fonction récursive est :  \t ", n);
	  
	  Bin_rec(n);
       printf("\n");       

      // appel de la fonction itérative 
	
       printf("la valeur de n= %d en base 2 avec la fonction iterative est:\t ",n);
       Bin_itera(n, &p);
        getch();              
        return 0;
 } // Fin du programme principal