Beispiel #1
0
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();
		}
	}
}
Beispiel #2
0
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);

}
Beispiel #3
0
void en_queue(void)
/* Positionne en queue de la liste */
{
	if(!liste_vide()) {
		ec = drapeau->pred;
	}
}
Beispiel #4
0
void en_tete(void)
/* Positionne en tete de la liste */
{
	if(!liste_vide()) {
		ec = drapeau->succ;
	}
}
Beispiel #5
0
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);
		}
	}
}
Beispiel #6
0
void DEBUG_liste_element (liste_element lel)
{
	while(!liste_vide(lel))
	{
		DEBUG_element (*lel);
		lel = lel -> next;
	}
}
Beispiel #7
0
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++;
	}
}
Beispiel #8
0
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();

		}
	}
}
Beispiel #9
0
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;
}
Beispiel #10
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;
}
Beispiel #11
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;
	}
}
Beispiel #14
0
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;
	
}
Beispiel #16
0
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");
	}
}
Beispiel #17
0
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();
			}
		}
	}
}
Beispiel #18
0
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;
}
Beispiel #19
0
/********************************************//**
* \brief Positionne en queue de la liste.
*
***********************************************/
void en_queue(void)
{
if(!liste_vide())
ec = drapeau->pred;
}
Beispiel #20
0
/********************************************//**
* \brief Positionne en tete de la liste.
*
***********************************************/
void en_tete(void)
{
if(!liste_vide())
ec = drapeau->succ;
}
Beispiel #21
0
void en_tete(void)
/* Positionne en tete de la liste */
{	
	if(!liste_vide()) 
		ec = 0;
}
Beispiel #22
0
void free_liste_element (liste_element * l)
{
	while( ! liste_vide(*l) )
		pop_element(l);
}
Beispiel #23
0
void en_queue(void)
/* Positionne en queue de la liste */
{	
	if(!liste_vide()) 
		ec = queue;
}