void vider_liste(void)
/* Supprime tous les éléments de la liste */
{
if(liste_vide()) {
printf("La liste est deja vide.\n");
} else {
en_queue();
while(!liste_vide()) {
oter_elt();
}
}
}
int main()
{
int i = 0;
int premier = 0;
sliste *l = liste_vide();
if (l == NULL)
{
printf("La liste est nulle\n");
}
l = ajout_tete(l,4);
l = ajout_tete(l,10);
l = ajout_tete(l,3);
sliste *new_l = l;
while (new_l != NULL)
{
printf("%d\n", new_l->e);
new_l = new_l->s;
}
premier = tete_liste(new_l);
printf("Le premier élément de la liste est %d", premier);
}
void en_queue(void)
/* Positionne en queue de la liste */
{
if(!liste_vide()) {
ec = drapeau->pred;
}
}
void en_tete(void)
/* Positionne en tete de la liste */
{
if(!liste_vide()) {
ec = drapeau->succ;
}
}
void inserer(t_valeurMot mot) {
/*Insère un élément dans la liste, en préservant l'ordre croissant des valeurs de la liste*/
int valeur, valeur_actuelle;
valeur = mot.score;
if(liste_vide()) {
ajout_droit(mot);
} else {
en_tete();
valeur_elt(&valeur_actuelle);
while(!hors_liste() && valeur_actuelle < valeur) {
suivant();
valeur_elt(&valeur_actuelle);
}
if(hors_liste()) {
en_queue();
ajout_droit(mot);
} else {
ajout_gauche(mot);
}
}
}
void DEBUG_liste_element (liste_element lel)
{
while(!liste_vide(lel))
{
DEBUG_element (*lel);
lel = lel -> next;
}
}
void ajout_gauche(t_personne v)
/* Ajoute v a gauche de l'elt courant */
{
int i;
if(liste_vide())
ec++;
if(liste_vide()||!hors_liste())
{
for(i=queue;i>=ec;i--){
liste[i+1].sexe=liste[i].sexe;
strcpy(liste[i+1].prenom,liste[i].prenom);
}
liste[ec].sexe=v.sexe;
strcpy(liste[ec].prenom,v.prenom);
queue++;
}
}
void vider_liste()
{
if(!liste_vide()){
en_queue();//on commence en fin de liste car on utilise oter_elt() qui se positionne sur le predecesseur
/*on enleve les elements un par un jusqu'à ce que la liste soit vide*/
while(!hors_liste()){
oter_elt();
}
}
}
int est_present(t_coord v){
t_coord valeur;
if(!liste_vide()){
en_tete();
while(!hors_liste()){
valeur_elt(&valeur);
if(valeur.x==v.x && valeur.y==v.y) return 1;
suivant();
}
}
return 0;
}
int main(void){
PERSONNE deValois = cree_personne("de Valois","Marguerite",1553,1615);
PERSONNE henriIV = cree_personne("IV","Henri",1553,1610);
PERSONNE deMedicis = cree_personne("de Medicis","Marie",1573,1642);
PERSONNE louisXIII = cree_personne("XIII","Louis",1601,1643);
PERSONNE anneDAutriche = cree_personne("d'Autriche","Anne",1601,1666);
PERSONNE louisXIV = cree_personne("XIV","Louis",1643,1715);
PERSONNE philippeDOrleans = cree_personne("d'Orleans","Philippe",1640,1701);
POINTEUR tout_le_monde = liste_vide();
OUTNF("\nUne personne:\n");
affiche_personne_abbrev(deValois);
OUTNF("\n");
ajoute_personne(deValois,tout_le_monde);
ajoute_personne(henriIV,tout_le_monde);
ajoute_personne(deMedicis,tout_le_monde);
ajoute_personne(louisXIII,tout_le_monde);
ajoute_personne(anneDAutriche,tout_le_monde);
ajoute_personne(louisXIV,tout_le_monde);
ajoute_personne(philippeDOrleans,tout_le_monde);
OUTNF("\nTout le monde:\n");
affiche_liste_abbrev(tout_le_monde);
OUTNF("\n");
ajoute_pere_enfant(henriIV,louisXIII);
ajoute_pere_enfant(louisXIII,philippeDOrleans);
ajoute_pere_enfant(louisXIII,louisXIV);
ajoute_mere_enfant(deMedicis,louisXIII);
ajoute_mere_enfant(anneDAutriche,philippeDOrleans);
ajoute_mere_enfant(anneDAutriche,louisXIV);
ajoute_conjoint(henriIV,deValois);
divorce(deValois);
ajoute_conjoint(henriIV,deMedicis);
ajoute_conjoint(louisXIII,anneDAutriche);
OUTNF("\nQuelques personnes:\n");
affiche_personne(deValois);
OUTNF("\n");
affiche_personne(henriIV);
OUTNF("\n");
affiche_personne(anneDAutriche);
OUTNF("\n");
affiche_personne(louisXIII);
OUTNF("\n");
return 0;
}
void ajout_droit(t_valeurMot m)
/* Ajoute v a droite de l'elt courant */
{
if(liste_vide()||!hors_liste())
{
t_element * nouvel_element = malloc(sizeof(t_element));
nouvel_element->mot = m;
nouvel_element->succ = ec->succ;
nouvel_element->pred = ec;
ec->succ = nouvel_element;
(nouvel_element->succ)->pred = nouvel_element;
ec = nouvel_element;
}
}
void ajout_gauche(int e) {
t_element * nouv;
if(liste_vide() || !hors_liste()) {
/* Création du nouvel élément */
nouv = malloc(sizeof(t_element));
/* Initialisation du nouvel élément */
nouv->valeur = e;
nouv->succ = ec;
nouv->pred = ec->pred;
/* Mise à jour des chaînages des voisins */
(ec->pred)->succ = nouv;
ec->pred = nouv;
/* On se positionne sur le nouvel élément */
ec = nouv;
}
}
void ajout_droit(int c, int p) {
t_element * nouv;
if(liste_vide() || !hors_liste()) {
/* Création du nouvel élément */
nouv = malloc(sizeof(t_element));
/* Initialisation du nouvel élément */
nouv->coeff = c;
nouv->puiss = p;
nouv->pred = ec;
nouv->succ = ec->succ;
/* Mise à jour des chaînages des voisins */
(ec->succ)->pred = nouv;
ec->succ = nouv;
/* On se positionne sur le nouvel élément */
ec = nouv;
}
}
void ajout_gauche(t_valeurMot m)
/* Ajoute v a gauche de l'elt courant */
{
if(liste_vide() || !hors_liste()) {
t_element * nouvel_element = malloc(sizeof(t_element));
nouvel_element->mot = m;
nouvel_element->pred = ec->pred;
nouvel_element->succ = ec;
(ec->pred)->succ = nouvel_element;
(ec->pred) = nouvel_element;
ec = nouvel_element;
}
}
Liste_Navires cree_liste_navires(Grille g, int n) {
int i, j;
int i2, j2;
Grille parcouru = allouer_grille(n);
Liste_Navires liste = liste_vide();
// Initialiser à non parcouru pour toutes les cases
for(i=0; i<n;i++){
for(j=0;j<n;j++){
parcouru[i][j]=0;
}
}
for(i=0; i<n; i++) { // Ligne
for(j=0; j<n; j++) { // Colonne
if(g[i][j] == 'N' && !(parcouru[i][j])) {
// Si on est sur un bateau qui n'est pas déjà dans la liste
parcouru[i][j] = 1;
if(g[i][j+1] == 'N') { // Bateau horizontal
parcouru[i][j+1] = 1;
j2 = j+1;
while(j2<n && g[i][j2] == 'N') {
parcouru[i][j2] = 1;
j2++;
}
insertion(&liste, i, j, i, j2-1);
}
else if(g[i+1][j] == 'N') { // Bateau vertical
parcouru[i+1][j] = 1;
i2 = i+1;
while(i2<n && g[i2][j] == 'N') {
parcouru[i2][j] = 1;
i2++;
}
insertion(&liste, i, j, i2-1, j);
}
}
}
}
return liste;
}
void afficher_liste(void)
/* Affiche les valeurs de la liste */
{
int elem;
if(liste_vide())
printf("La liste est vide\n");
else
{
printf("\nLa liste contient: ");
en_tete();
while(!hors_liste())
{
valeur_elt(&elem);
printf("%s : %i\n", elem.score, elem.mot);
suivant();
}
printf("\n");
}
}
void supprimer(void)
/* Supprime toutes les occurrences d'un entier lu au clavier */
{
int valeur;
int valeur_actuelle;
if(liste_vide()) {
printf("La liste est vide\n");
} else {
printf("\nEntrez l'entier a supprimer dans la liste : ");
scanf("%i", &valeur);
en_queue();
while(!hors_liste()) {
valeur_elt(&valeur_actuelle);
if(valeur_actuelle == valeur) {
oter_elt();
} else {
precedent();
}
}
}
}
liste_t lire_fichier_vers_liste(FILE * fic, int * lu, size_t taille, lecture_fun lire) {
void * element = NULL;
liste_t liste = liste_vide();
assert(NULL != lu);
/* allocation initiale de memoire pour la lecture de la premiere entree */
element = malloc(taille);
if (NULL == element) {
perror("lire_fichier_vers_liste : echec de l'allocation memoire (1)");
exit(1);
}
/* lecture des donnees dans le fichier : une entree est lue par
* un appel a la fonction fournie comme quatrieme argument
*/
*lu = 0;
while ((*lire)(fic, element)) {
++(*lu);
liste_ajouter_a_la_fin(element, liste);
/* allocation initiale de memoire pour la lecture de l'entree suivante */
element = malloc(taille);
if (NULL == element) {
perror("lire_fichier_vers_liste : echec de l'allocation memoire (2)");
exit(1);
}
}
/* liberation de la memoire allouee pour le dernier element
* (dont la lecture a ete incomplete)
*/
free(element);
/* renvoyer le resultat */
return liste;
}
/********************************************//**
* \brief Positionne en queue de la liste.
*
***********************************************/
void en_queue(void)
{
if(!liste_vide())
ec = drapeau->pred;
}
/********************************************//**
* \brief Positionne en tete de la liste.
*
***********************************************/
void en_tete(void)
{
if(!liste_vide())
ec = drapeau->succ;
}
void en_tete(void)
/* Positionne en tete de la liste */
{
if(!liste_vide())
ec = 0;
}
void free_liste_element (liste_element * l)
{
while( ! liste_vide(*l) )
pop_element(l);
}
void en_queue(void)
/* Positionne en queue de la liste */
{
if(!liste_vide())
ec = queue;
}