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

typedef struct scouple 
{char variable; int valeur;} couple;

typedef struct liste
{
  couple c;
  struct liste *suivant;
} Sliste, *Liste;

/*typedef struct liste
{
  char c;
  struct liste *suivant;
} Sliste, *Liste;
*/
Sliste* vide()
{
  return NULL;
}

Sliste* ajout(char v, int e, Sliste *l)
{
  Sliste *m = (Sliste *)malloc(sizeof(Sliste));
  m->suivant = l;
  (m->c).variable=v;
  (m->c).valeur=e;
  return m;
}

Sliste* ajout_couple(couple c, Sliste *l)
{
  return ajout(c.variable, c.valeur, l);
}

void affiche_liste(Sliste *l)
{
  while (l!=NULL)
    {
      printf("(%c,%d) ",(l->c).variable,(l->c).valeur);
      l=l->suivant;
    }
  printf(".\n");
}

void affiche_liste_rec(Sliste *l)
{
  if (l!=NULL)
    {
      printf("(%c,%d) ",(l->c).variable,(l->c).valeur);
      affiche_liste_rec(l->suivant);
    }
  else printf(".\n");
}

int appartient(char t, Sliste *l)
{
  if (l==NULL) 
    {
      return 0;
    }
  else
    {
      return ((t==(l->c).variable) || appartient(t, l->suivant));
    }
}

int sans_doublons(Sliste *l)
{
  if (l==NULL)
    {
      return 1;
    }
  else
    {
      return (!appartient((l->c).variable, l->suivant) && sans_doublons(l->suivant));
    }
}

Sliste *maj(char t, int val, Sliste *l)
{
  if (l==NULL)
    return NULL; /* la variable n'existait pas */
  else
    {
      if((l->c).variable==t) 
	{
	  (l->c).valeur=val; /* ici on fait un effet de bord, alors que jusqu'a maintenant on avait un style purement fonctionnel */
	  return l;
	}
      else return (ajout_couple(l->c, maj(t,val, l->suivant)));
    }
}

Sliste* renv_acc(Sliste *l1, Sliste *l2)
{
  if (l1==NULL) return l2;
  else
    return (renv_acc(l1->suivant, ajout_couple(l1->c, l2)));
}

Sliste* renverse(Sliste *l)
{
  return renv_acc(l, NULL);
}

int main()
{   
printf("listes d'association : tests\n");
 Sliste *l = vide();
 
 Sliste *m = ajout('x', 3, ajout ('y', -9, ajout ('z', 0, vide())));

couple c1, c2,c3;
 c1.variable = 'x';
 c1.valeur = 3;

 c2.variable = 'y';
 c2.valeur = -9;

 c2.variable = 'z';
 c2.valeur = 0;

 Sliste *n = ajout_couple (c1, ajout_couple(c2, ajout_couple (c3, vide())));
 printf("affichage liste vide : ");
 affiche_liste(l);
 printf("la liste de l'exemple : ");
 affiche_liste(m);
 printf("la liste de l'exemple (avec ajout_couple) : ");
 affiche_liste(m);
 printf("appartient x ? %d\n",appartient('x',m));
 printf("appartient w ? %d\n",appartient('w',m));
 printf("sans_doublons m ? %d\n",sans_doublons(m));
 printf("sans_doublons x,m ? %d\n",sans_doublons(ajout('x',5,m)));
 printf("sans_doublons y,m ? %d\n",sans_doublons(ajout('y',3,m)));
 printf("sans_doublons z,m ? %d\n",sans_doublons(ajout('z',9,m)));
 printf("renverse -> : ");
 affiche_liste(renverse(m));
 printf("maj t -> 17 : ");
 affiche_liste(maj('t', 17, m));
 printf("maj z -> -1 : ");
 affiche_liste(maj('z', -1, m));
 printf("maj x -> 0 : "); 
 affiche_liste(maj('x', 0, m));
 printf("maj y -> 0 : "); 
 affiche_liste(maj('y', 0, m));
 printf("ok\n");
 return 0;
}
