/*  Il s'agit de programmer le tri baquet. Ce tri peut être appliqué à des
chaînes de caractères ou à des entiers positifs ou nuls. Nous considérons 
ici le cas des entiers.
	On suppose que les données positives ou nulles sont écrites en 
écriture décimale avec au plus k chiffres, autrement dit que les données 
sont inférieures à 10 puissance k.
	On utilise un tableau, dit tableau de "baquets", indicé par 
0, 1, ...., 9. Chacun des baquets est une structure contenant deux 
pointeurs destinés à contenir les adresses du début et de la fin d'une 
liste chaînée d'entiers.
	L'algorithme se déroule de la façon suivante :
1) On chaîne les données : soit L la liste obtenue.
2) Pour i qui varie de 1 à k :
	a) On initialise à "rien" toutes les adresses des baquets.
	b) On prend un à un les maillons de L. Pour chaque maillon m :
	       	- on note n la donnée contenue dans m
		- on note num le ième chiffre de n en partant de la 
		droite (par exemple, si i=1, num est le chiffre des 
		unités de n)
		- on chaîne m à la fin de la liste chaînée contenue 
		par baquet[num]
	c) On reconstitue une liste L en chaînant "bout à bout" le contenu 
	de baquet[0], puis de baquet[1], ..., puis de baquet[9].

	Dans ce programme, les données à trier sont lues dans le fichier 
	"donnees.dat" ; les données triées seront rangées dans le fichier 
	"resultats.dat".
	Vous devez écrire les fonctions correspondant aux points 2)b) 
	(fonction ranger) et 2)c) (fonction reconstruire) ci-dessus.*/

#include <stdio.h>
#include <stdlib.h>

typedef struct maillon
{
  int entier;
  struct maillon * suivant;
} Maillon;

typedef Maillon * VersMaillon;

VersMaillon L = NULL; /*pour chaîner les données */
int k;     /* contiendra le nombre maximum de chiffres des données à trier*/

struct
{
  VersMaillon deb,fin;
} baquet[10];

FILE *lecture,*ecriture;

/*********    prototypes des fonctions utilisées     ********/
/* Voir plus bas leurs spécifications externers */
void entrerDonnees(void);
void trier(void);
void afficher(void);
void initialiserBaquets(void);
void ranger(void);
void reconstruire(void);


int main(void)
{
  entrerDonnees(); 
  trier();
  afficher();
  return 0;
}

/* Ouvre le fichier "donnees.dat" pour y lire le nombre k et
   les données à trier ; construit la liste chaînée dont le début
   est à l'adresse L, qui contient l'ensemble des données */
void entrerDonnees()
{
}

/* Après avoir appliqué cette fonction, les données contenues dans la 
   liste L se trouvent ordonnées par ordre croissant.
   On rappelle l'algorithme :
   Pour i qui varie de 1 à k : 
     - On initialise à "rien" toutes les adresses des baquets. 
     - On range tous les maillons de L dans le baquet convenable. 
     - On reconstitue une liste L. 
On utilisera les fonctions dont les corps se trouvent plus bas.*/
void trier() 
{
}

/* met toutes les adresses des baquets à NULL */
void initialiserBaquets()
{
}

/* D'abord un détail : cette fonction contiendra une variable statique,
   notée puiss, qui vaudra 1 au premier appel et sera multipliée par 10 
   à la fin de chaque appel. 

   Supposons qu'il s'agisse du ième appel de la fonction ranger. 
   la variable puiss vaut 10 puissance (i - 1).
   La fonction prend un à un les maillons de L. Pour chaque maillon m, 
   notons n la donnée contenue ; la fonction calcule le ième chiffre 
   de n en partant de la droite (on peut utiliser ici la variable puiss) ; 
   soit num ce chiffre ; la fonction chaîne m dans baquet[num] en 
   actualisant les pointeurs deb et fin*/
void ranger() 
{
}


/* chaîne bout à bout les contenus de baquet[0], baquet[1], ... , baquet[9].
   Ne pas oublier que certains baquets peuvent être vides. */
void reconstruire(void)
{
}


/* Affiche la liste triée dans le fichier "resultats.dat" */
void afficher(void)
{
}