Skip to content
Snippets Groups Projects
Commit 7a146028 authored by lucie's avatar lucie
Browse files

projet tas binaire

contient les fonctions de bases (init, liberation, ajouter, retirer)
parent 0ce47523
Branches tas-binaire
No related tags found
No related merge requests found
#ifndef _BOOL_H
#define _BOOL_H
typedef enum
{
FALSE, // = 0
TRUE // = 1
} bool_t;
#endif
\ No newline at end of file
#include "liste.h"
/*****************************************************/
/* creerListe() */
/* */
/* Allocation mémoire d'une liste de type */
/* liste_t et initialisation du pointeur si réussite.*/
/* */
/* Input : */
/* Output : pointeur sur l'élément de type liste_t */
/*****************************************************/
liste_t *creerListe()
{
liste_t *nouvelle = (liste_t *)malloc(sizeof(liste_t));
if (nouvelle == NULL)
{
fprintf(stderr, "Allocation mémoire imposible de la liste.\n");
exit(1);
}
nouvelle->tete = NULL;
return nouvelle;
}
/*****************************************************/
/* viderListe() */
/* */
/* suppression des éléments de la liste pointée un à */
/* un. */
/* */
/* Input : liste (pointeur sur liste) */
/* Output : */
/*****************************************************/
void viderListe(liste_t *liste)
{
while (liste->tete != NULL) //tant que le pointeur sur la tête de liste ne pointe pas sur NULL
{
supprimerElement(&(liste->tete));
}
liste->tete = NULL;
}
/*****************************************************/
/* supprimerElement() */
/* */
/* Libération de l'espace mémoire allouée à une */
/* cellule. L'adresse du précédent est passée en */
/* paramètre, ce qui permet le resspect du chainage */
/* après suppression de l'élément */
/* */
/* Input : prec (pointeur sur le pointeur de */
/* l'élément suivant du précédent) */
/* Output : */
/*****************************************************/
void supprimerElement(maillon_t **prec)
{
if (*prec != NULL)
{
maillon_t *aSuppr = *prec;
*prec = aSuppr->suiv;
free(aSuppr);
}
else
{
fprintf(stderr, "Suppression de cellule impossible.\n");
}
}
/*****************************************************/
/* insererListe() */
/* */
/* Insert une nouvelle valeur, passée en paramètre, */
/* à la suite de l'élément donnée. */
/* */
/* Input : prec (pointeur sur le pointeur de */
/* l'élément suivant du précédent) */
/* valeur (valeur à inserer) */
/* Output : */
/*****************************************************/
void insererListe(maillon_t **prec, elem_t valeur)
{
maillon_t *cour = (maillon_t *)malloc(sizeof(maillon_t));
if (cour == NULL)
{
fprintf(stderr, "Allocation mémoire de la cellule imposible.\n");
exit(1);
}
cour->elem = valeur;
cour->suiv = *prec;
*prec = cour;
}
#ifndef _LISTE_H_
#define _LISTE_H_
#include <stdlib.h>
#include <stdio.h>
#include "type.h"
typedef struct maillon
{
elem_t elem; //element de la cellule
struct maillon *suiv; //poiteur sur la cellule suivante
} maillon_t;
typedef struct liste
{
maillon_t *tete; //poiteur sur la cellule de tête de liste
} liste_t;
liste_t *creerListe();
void viderListe(liste_t *);
void supprimerElement(maillon_t **);
void insererListe(maillon_t **, elem_t);
#endif
\ No newline at end of file
#include"main.h"
int main(int argc, char** argv){
return 0;
}
\ No newline at end of file
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(int argc, char** argv);
\ No newline at end of file
#include "noeudTB.h"
noeud * initNoeud(){
noeud_t *nouveau = (noeud_t*)malloc(sizeof(noeud_t));
if(nouveau == NULL){
fprintf(stderr, "Allocation mémoire imposible du noeud : %.\n", errno);
}
else{
nouveau->fd = NULL;
nouveau->fg = NULL;
}
return nouveau;
}
void afficherNoeud(noeud_t noeud){
printf("\nValeur du noeud :\n%d\n", noeud.distance);
}
\ No newline at end of file
#ifndef _NOEUD_TAS_BIN_H_
#define _NOEUD_TAS_BIN_H_
#include <stdlib.h>
#include <stdio.h>
#include "errno.h"
typedef struct noeud{
struct noeud *fd; //fils droit
struct noeud *fg; //fils gauche
int distance
} noeud_t;
noeud_t * initNoeud();
void afficherNoeud(noeud_t)
#endif
\ No newline at end of file
#include "pile.h"
/*****************************************************/
/* creerPile() */
/* */
/* Allocation mémoire d'une pile de type */
/* pile_t par l'appel de creerListe */
/* */
/* Input : */
/* Output : pointeur sur l'élément de type pile_t */
/*****************************************************/
pile_t *creerPile()
{
pile_t *pile = creerListe();
return pile;
}
/*****************************************************/
/* libererPile() */
/* */
/* libération de l'espace mémoire alloué à la pile, */
/* par l'appel de viderListe. */
/* */
/* Input : pile (pointeur sur pile) */
/* Output : */
/*****************************************************/
void libererPile(pile_t *pile)
{
viderListe(pile);
free(pile);
}
/*****************************************************/
/* empiler() */
/* */
/* Insert une nouvelle valeur, passée en paramètre */
/* dans la pile pointée, par l'appel de insererListe.*/
/* */
/* Input : pile (pointeur sur la pile) */
/* valeur (valeur à inserer) */
/* Output : */
/*****************************************************/
void empiler(pile_t *pile, elem_t valeur)
{
insererListe(&(pile->tete), valeur);
}
/*****************************************************/
/* dépiler() */
/* */
/* Supprime l'élément en haut de la pile, par l'appel*/
/* de supprimerElement. */
/* */
/* Input : pile (pointeur sur la pile) */
/* Output : */
/*****************************************************/
void depiler(pile_t *pile)
{
supprimerElement(&(pile->tete));
}
/*****************************************************/
/* dépilerSansSuppression() */
/* */
/* Retourne l'élément en haut de la pile, et le */
/* depile. */
/* */
/* Input : pile (pointeur sur la pile) */
/* Output : */
/*****************************************************/
elem_t depilerSansSuppression(pile_t *pile)
{
elem_t sommet = sommetPile(pile);
depiler(pile);
return sommet;
}
/*****************************************************/
/* sommetPile() */
/* */
/* Renvoie la valeur de la tête de pile c'est à dire */
/* le prochain élement qui sera dépilé. */
/* */
/* Input : pile (pointeur sur la pile) */
/* Output : valeur de l'élément en tête de pile */
/*****************************************************/
elem_t sommetPile(pile_t *pile)
{
return pile->tete->elem;
}
/*****************************************************/
/* estVide() */
/* */
/* Retourne si la pile est vide (1) ou non (0) en */
/* vérifiant si le pointeur sur la tête de liste */
/* vaut NULL ou non. */
/* */
/* Input : pile (pointeur sur la pile) */
/* Output : entier de type bool_t */
/*****************************************************/
bool_t estVide(pile_t *pile)
{
bool_t vide = FALSE;
if (pile->tete == NULL)
vide = TRUE;
return vide;
}
/*****************************************************/
/* depilerJusquA() */
/* */
/* Dépile jusqu'à l'élément courant pointer. */
/* */
/* Input : pile (pointeur sur la pile), courant */
/* (pointeur sur un noeud) */
/* Output : */
/*****************************************************/
void depilerJusquA(pile_t * pileMot, noeud_t * courant)
{
while(sommetPile(pileMot) != courant)
{
depiler(pileMot);
}
depiler(pileMot);
}
\ No newline at end of file
#ifndef _PILE_H_
#define _PILE_H_
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "type.h"
#include "liste.h"
#include "bool.h"
typedef liste_t pile_t;
pile_t *creerPile();
void libererPile(pile_t *);
void empiler(pile_t *, elem_t);
void depiler(pile_t *);
elem_t sommetPile(pile_t *);
bool_t estVide(pile_t *);
elem_t depilerSansSuppression(pile_t*);
void depilerJusquA(pile_t *, noeud_t *);
#endif
\ No newline at end of file
#include "tasBinaire.h"
tasBinaire_t * initTas(){
tasBinaire_t *nouveau = (tasBinaire_t*)malloc(sizeof(tasBinaire_t));
void initTas(noeud_t tas[TAILLEMAX]){
int i=0;
for(i;i<TAILLEMAX; i++){
tas[i].nomSommet = 0;
tas[i].distance = 0;
}
}
noeud_t * initNoeud(int id, int dist){
noeud_t *nouveau = (noeud_t*)malloc(sizeof(noeud_t));
if(nouveau != NULL){
nouveau->nomSommet = id;
nouveau->distance = dist;
} else{
fprintf(stderr, "errno : %d", errno);
}
return nouveau;
}
noeud_t * rechercheMerePlaceLibre(noeud_t *debut, int valeur, pile_t *pile){
void inverser2Noeuds(int indiceA, int indiceB, noeud_t tas[TAILLEMAX]){
noeud_t tmp = tas[indiceA];
tas[indiceA] = tas[indiceB];
tas[indiceB] = tmp;
}
void recherchePlace(noeud_t *aRanger, pile_t *pileDeParcourt){
bool_t trouver = FALSE;
while(trouver != TRUE && estVide(pileDeParcourt)==FALSE){
if(aRanger->distance < sommetPile(pileDeParcourt)->distance){
//noeud_t *tmpfd = aRanger;
void insererNoeud(noeud_t *aRanger, noeud_t tas[TAILLEMAX]){
int i=0, trouver = 0;
while(tas[i].nomSommet != 0){ //on considère l'identifiant de sommet 0 comme invalide
i++;
}
tas[i] = *aRanger;
while(trouver !=1 && i != 0){
if(tas[i].distance < tas[(i-1)/2].distance){
inverser2Noeuds(i, (i-1)/2, tas);
i = (i-1)/2;
}else{
trouver = 1;
}
}
}
void insererNoeud(noeud_t *aRanger, tasBinaire *tas){
pile_t pileDesMeres = NULL;
noeud_t *mère = rechercheMerePlaceLibre(tas->racine, aRanger->distance, &pileDesMeres);
if(mere->fd == NULL){
mere->fd = aRanger;
void retirerNoeud(noeud_t *aRetirer, noeud_t tas[TAILLEMAX]){
int i = 0, indiceARetirer, existe = 0, trouver = 0;
while(tas[i].nomSommet != 0){
if(tas[i].nomSommet == aRetirer->nomSommet){
indiceARetirer = i;
existe = 1;
}
i++;
}
else{
mere->fg = aRanger;
i--;
if(existe != 1)
printf("\nCe noeud n'est pas dans le tas \n\n");
else {
inverser2Noeuds(indiceARetirer, i, tas);
tas[i].nomSommet = 0;
tas[i].distance = 0;
i = indiceARetirer;
while(trouver != 1){
if(tas[i].distance > tas[(2*i) +1].distance && tas[(2*i) +1].nomSommet != 0){
inverser2Noeuds(i, (2*i) +1, tas);
i = (2*i) +1;
}
else{
if(tas[i].distance > tas[(2*i) +2].distance && tas[(2*i) +2].nomSommet != 0){
inverser2Noeuds(i, (2*i) +2, tas);
i = (2*i) +2;
}
else
trouver = 1;
}
}
}
recherchePlace(aRanger, &pileDesMeres);
viderPile(pileDesMeres);
}
void libererNoeud(noeud_t *aLiberer){
free(aLiberer);
}
void afficherTas(noeud_t tas[TAILLEMAX]){
int i = 0;
for(i;i<TAILLEMAX; i++){
printf("sommet : %d\ndistance : %d\n\n",tas[i].nomSommet, tas[i].distance);
}
}
#ifndef _TAS_BIN_H_
#define _TAS_BIN_H_
#define TAILLEMAX 10
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <errno.h>
#include "noeudTB.h"
#include "pile.h"
#include "bool.h"
typedef struct tasBinaire{
noeud_t racine;
}tasBinaire_t;
tasBinaite_t * initTas();
typedef struct noeud{
int nomSommet;
int distance;
} noeud_t;
noeud_t* initNoeud(int, int);
void initTas(noeud_t tas[TAILLEMAX]);
void insererNoeud(noeud_t *, noeud_t tas[TAILLEMAX]);
void retirerNoeud(noeud_t *, noeud_t tas[TAILLEMAX]);
void libererNoeud(noeud_t *);
void afficherTas(noeud_t tas[TAILLEMAX]);
#endif
\ No newline at end of file
#ifndef _TYPE_H_
#define _TYPE_H_
#include "noeud.h"
typedef noeud_t *elem_t;
#endif
\ No newline at end of file
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment