version sans erreur 1

Makefile

 all: test_graphe
 
-test_graphe: test_graphe.o graphe.o io_graphe.o
-	gcc -o test_graphe test_graphe.o graphe.o io_graphe.o
+test_graphe: test_graphe.o graphe.o io_graphe.o fap.o
+	gcc -o test_graphe test_graphe.o graphe.o io_graphe.o fap.o
 
-graphe.o: graphe.c graphe.h
+graphe.o: graphe.c graphe.h 
 	gcc -Wall -c graphe.c
 
 io_graphe.o: io_graphe.c graphe.h
 	gcc -Wall -c io_graphe.c
 
+fap.o: fap.c fap.h
+	gcc -Wall -c fap.c
 
 test_graphe.o: test_graphe.c graphe.h
 	gcc -Wall -c test_graphe.c

data/complet

+2
+0
+1
+0 1 7
+1 0 8
\ No newline at end of file

data/independant

+4
+0
+2
+5
+8
+0 0 2
+2 0 7
+8 0 8
\ No newline at end of file

fap.c

+#include "fap.h"
+#include <stdlib.h>
+#include <stdbool.h>
+
+fap creer_fap_vide() {
+    return NULL; 
+}
+
+fap inserer(fap f, void* element, int priorite) {
+    fap nouveau = (fap)malloc(sizeof(struct maillon)); 
+    nouveau->element = element; 
+    nouveau->priorite = priorite; 
+    nouveau->prochain = NULL; 
+
+    if (f == NULL) { 
+        return nouveau; 
+    } else { 
+        fap courant = f;
+        fap precedent = NULL;
+
+        while (courant != NULL && priorite >= courant->priorite) {
+            precedent = courant;
+            courant = courant->prochain;
+        }
+
+        if (precedent == NULL) { 
+            nouveau->prochain = f;
+            return nouveau;
+        } else { 
+            precedent->prochain = nouveau;
+            nouveau->prochain = courant;
+            return f;
+        }
+    }
+}
+
+fap extraire(fap f, void* *element, int *priorite) {
+    if (f == NULL) { 
+        return NULL;
+    }
+
+    fap extrait = f; 
+    *element = extrait->element;
+    *priorite = extrait->priorite; 
+
+    f = f->prochain; 
+    free(extrait); 
+    return f; 
+}
+
+int est_fap_vide(fap f) {
+    return f == NULL; 
+}
+
+void detruire_fap(fap f) {
+    while (!est_fap_vide(f)) { 
+        void* element;
+        int priorite;
+        f = extraire(f, &element, &priorite);
+    }
+}

fap.h

+#ifndef __FAP_H__
+#define __FAP_H__
+
+struct maillon;
+
+typedef struct maillon *fap;
+
+struct maillon {
+    void* element;
+    int priorite;
+    fap prochain;
+};
+
+fap creer_fap_vide();
+
+
+fap inserer(fap f, void* element, int priorite);
+
+fap extraire(fap f, void* *element, int *priorite);
+
+
+int est_fap_vide(fap f);
+
+
+void detruire_fap(fap f);
+
+#endif

file.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "file.h"
+
+
+File *creer_file(psommet_t sommet) {
+    File *nouveau = (File *)malloc(sizeof(File));
+    if (nouveau == NULL) {
+        fprintf(stderr, "Erreur : Impossible de créer une nouvelle file\n");
+        exit(EXIT_FAILURE);
+    }
+    nouveau->sommet = sommet;
+    nouveau->suivant = NULL;
+    return nouveau;
+}
+
+void enfiler(File **file, psommet_t sommet) {
+    File *nouveau = creer_file(sommet);
+    if (*file == NULL) {
+        *file = nouveau;
+    } else {
+        File *tmp = *file;
+        while (tmp->suivant != NULL) {
+            tmp = tmp->suivant;
+        }
+        tmp->suivant = nouveau;
+    }
+}
+
+psommet_t defiler(File **file) {
+    if (*file == NULL) {
+        fprintf(stderr, "Erreur : Tentative de défiler une file vide\n");
+        exit(EXIT_FAILURE);
+    }
+    File *tmp = *file;
+    psommet_t sommet = tmp->sommet;
+    *file = (*file)->suivant;
+    free(tmp);
+    return sommet;
+}
+
+int est_vide(File *file) {
+    return (file == NULL);
+}
\ No newline at end of file

file.h

+#ifndef FILE_H
+#define FILE_H
+
+#include "graphe.h" 
+
+typedef struct file {
+    psommet_t sommet;
+    struct file *suivant;
+} File;
+
+File *creer_file(psommet_t sommet);
+void enfiler(File **file, psommet_t sommet);
+psommet_t defiler(File **file);
+int est_vide(File *file);
+
+#endif

graphe.c

@@ -8,8 +8,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <limits.h>
-
+#include "fap.h"
 #include "graphe.h"
+#include "stdbool.h"
 
 
 psommet_t chercher_sommet (pgraphe_t g, int label)
@@ -187,14 +188,59 @@ void afficher_graphe_profondeur (pgraphe_t g, int r)
   return ;
 }
 
-void algo_dijkstra (pgraphe_t g, int r)
-{
-  /*
-    algorithme de dijkstra
-    des variables ou des chanmps doivent etre ajoutees dans les structures.
-  */
+void initialiser_distance_racine(pgraphe_t graphe, int infini) {
+    psommet_t sommet = graphe;
+    while (sommet != NULL) {
+        sommet->distance_racine = infini;
+        sommet = sommet->sommet_suivant;
+    }
+}
 
-  return ;
+void algo_dijkstra(pgraphe_t g, int r) {
+    if (!g) 
+        return;
+
+    init_couleur_sommet(g);
+    initialiser_distance_racine(g, INT_MAX); 
+
+    fap file = creer_fap_vide(); 
+    psommet_t sommet_depart = chercher_sommet(g, r); 
+    if (!sommet_depart) 
+        return;
+
+    sommet_depart->distance_racine = 0;
+
+    file = inserer(file, sommet_depart, sommet_depart->distance_racine); 
+
+    while (!est_fap_vide(file)) { 
+        int distance;
+        psommet_t sommet_courant;
+        file = extraire(file, (void **)&sommet_courant, &distance); 
+
+        sommet_courant->couleur = 1; 
+
+        for (parc_t arc = sommet_courant->liste_arcs; arc != NULL; arc = arc->arc_suivant) {
+            
+            if (arc->dest->couleur == 0 || arc->dest->distance_racine > distance + arc->poids) {
+                arc->dest->couleur = 1; 
+                arc->dest->distance_racine = distance + arc->poids; 
+                file = inserer(file, arc->dest, arc->dest->distance_racine); 
+            }
+        }
+    }
+}
+
+void afficher_dijkstra(pgraphe_t g) {
+    bool aucun_chemin_trouve = true;
+    for (psommet_t s = g; s != NULL; s = s->sommet_suivant) {
+        if (s->distance_racine != INT_MAX) { 
+            aucun_chemin_trouve = false; 
+            printf("Le sommet %d est accessible à une distance de %d\n", s->label, s->distance_racine);
+        }
+    }
+    if (aucun_chemin_trouve) { 
+        printf("Aucun chemin trouvé dans le graphe.\n");
+    }
 }
 
 
@@ -206,76 +252,125 @@ void algo_dijkstra (pgraphe_t g, int r)
 
 
 
-int degre_sortant_sommet (pgraphe_t g, psommet_t s)
-{
-  /*
-    Cette fonction retourne le nombre d'arcs sortants 
-    du sommet n dans le graphe g
-  */ 
+int degre_sortant_sommet  (pgraphe_t g, psommet_t s) {
+    int degre = 0;
+    parc_t arc = s->liste_arcs;
+    while (arc != NULL) {
+        degre++; 
+        arc = arc->arc_suivant; 
+    }
+    return degre; 
+    }
+
+int degre_entrant_sommet  (pgraphe_t g, psommet_t s) {
+    int degre = 0;
+    for (psommet_t sommet = g; sommet != NULL; sommet = sommet->sommet_suivant) {
+        parc_t arc = sommet->liste_arcs;
+        while (arc != NULL) {
+
+            if (arc->dest == s) {
+                degre++;
+            }
+            arc = arc->arc_suivant;
+        }
+    }
 
-  return 0 ;
+    return degre;
 }
 
-int degre_entrant_sommet (pgraphe_t g, psommet_t s)
-{
-  /*
-    Cette fonction retourne le nombre d'arcs entrants 
-    dans le noeud n dans le graphe g
-  */ 
 
-  return 0 ;
-}
+int degre_maximal_graphe  (pgraphe_t g) {
+    int degre_maximal = 0; 
 
-int degre_maximal_graphe (pgraphe_t g)
-{
-  /*
-    Max des degres des sommets du graphe g
-  */
+    for (psommet_t sommet = g; sommet != NULL; sommet = sommet->sommet_suivant) {
+        int degre = degre_sortant_sommet(g, sommet);
+        if (degre > degre_maximal) {
+            degre_maximal = degre; 
+        }
+    }
 
-  return 0 ;
+    return degre_maximal;
 }
 
+int degre_minimal_graphe  (pgraphe_t g) {
+    int degre_minimal = INT_MAX; 
 
-int degre_minimal_graphe (pgraphe_t g)
-{
-  /*
-    Min des degres des sommets du graphe g
-  */
-
-  return 0 ;
+    for (psommet_t sommet = g; sommet != NULL; sommet = sommet->sommet_suivant) {
+        int degre = degre_sortant_sommet(g, sommet); 
+        if (degre < degre_minimal) {
+            degre_minimal = degre; 
+        }
+    }
+    return degre_minimal;
 }
 
 
 int independant (pgraphe_t g)
 {
-  /* Les aretes du graphe n'ont pas de sommet en commun */
+    return degre_maximal_graphe(g) <= 1;// si c'est plus cad  que directement y'a des sommets en communs 
+} 
+
+
+
+int complet (pgraphe_t g) {
+    for (psommet_t sommet1 = g; sommet1 != NULL; sommet1 = sommet1->sommet_suivant) {
+        for (psommet_t sommet2 = sommet1->sommet_suivant; sommet2 != NULL; sommet2 = sommet2->sommet_suivant) {
+            int a_relie = 0;
+            for (parc_t arc = sommet1->liste_arcs; arc != NULL; arc = arc->arc_suivant) {
+                if (arc->dest == sommet2) {
+                    a_relie = 1;
+                    break;
+                }
+            }
+            if (!a_relie) {
+                return 0;
+            }
+        }
+    }
+    return 1; 
+}
+
 
-  return 0 ;
+int regulier(pgraphe_t g) {
+    int degre = degre_sortant_sommet(g, g);
+
+    for (psommet_t sommet = g->sommet_suivant; sommet != NULL; sommet = sommet->sommet_suivant) {
+        if (degre_sortant_sommet(g, sommet) != degre) {
+            return 0;
+        }
+    }
+    return 1; 
 }
 
 
+int elementaire(pgraphe_t g, chemin_t c) {
+    psommet_t sommet = chercher_sommet(g, c.permier_sommet->label);
+    if (sommet == NULL) {
+        printf("Le sommet initial n'existe pas dans le graphe.\n");
+        return 0;
+    }
 
-int complet (pgraphe_t g)
-{
-  /* Toutes les paires de sommet du graphe sont jointes par un arc */
+    psommet_t sommet_precedent = NULL;
+    for (parc_t arc = c.liste_arcs; arc != NULL; arc = arc->arc_suivant) {
+        if (sommet_precedent != NULL && sommet_precedent == arc->dest) {
+            printf("Le chemin n'est pas élémentaire. Il passe deux fois par le sommet %d.\n", arc->dest->label);
+            return 0;
+        }
+        sommet_precedent = arc->dest;
 
-  return 0 ;
-}
+        if (existence_arc(sommet->liste_arcs, arc->dest) == NULL) {
+            printf("Le chemin n'est pas élémentaire. Il n'y a pas d'arc entre les sommets %d et %d.\n", sommet->label, arc->dest->label);
+            return 0;
+        }
 
-int regulier (pgraphe_t g)
-{
-  /* 
-     graphe regulier: tous les sommets ont le meme degre
-     g est le ponteur vers le premier sommet du graphe
-     renvoie 1 si le graphe est régulier, 0 sinon
-  */
+        sommet = arc->dest;
+    }
 
-  return 0 ;
+    return 1;
 }
 
 
 
-
 /*
   placer les fonctions de l'examen 2017 juste apres
 */

graphe.h

@@ -12,6 +12,7 @@ typedef struct s
   parc_t     liste_arcs ; // arcs sortants du sommet
   struct s   *sommet_suivant ; // sommet suivant dans le graphe
   int        couleur ; // couleur du sommet
+  int         distance_racine;
 } sommet_t, *psommet_t ;
 
 /*
@@ -34,6 +35,14 @@ typedef struct a {
 
 typedef psommet_t pgraphe_t ;
 
+
+typedef struct c{
+    psommet_t permier_sommet;
+    parc_t liste_arcs;
+} chemin_t, *pchemin_t;
+
+
+
 psommet_t chercher_sommet (pgraphe_t g, int label) ;
 
 void ajouter_arc (psommet_t o, psommet_t d, int distance) ;
@@ -57,3 +66,14 @@ void afficher_graphe_profondeur (pgraphe_t g, int r) ;
 void afficher_graphe_largeur (pgraphe_t g, int r) ;
 
 void algo_dijkstra (pgraphe_t g, int r) ;
+void afficher_dijkstra(pgraphe_t g);
+int degre_sortant_sommet(pgraphe_t g, psommet_t s) ;
+int degre_entrant_sommet(pgraphe_t g, psommet_t s) ;
+int degre_maximal_graphe(pgraphe_t g) ;
+int degre_minimal_graphe(pgraphe_t g) ;
+int independant (pgraphe_t g);
+
+int complet (pgraphe_t g) ;
+
+int regulier(pgraphe_t g);
+

test_graphe.c

@@ -6,7 +6,6 @@
 int main (int argc, char **argv)
 {
   pgraphe_t g ;
-  int nc ;
   
   if (argc != 2)
     {
@@ -30,10 +29,46 @@ int main (int argc, char **argv)
   fflush (stdout) ;
   
   ecrire_graphe (g) ;      
-
+  int nc ;
   nc = colorier_graphe (g) ;
   
   printf ("nombre chromatique graphe = %d\n", nc) ;
-
+  
   ecrire_graphe_colorie (g) ;
-}
+
+
+  printf("\n                                    Algo Dijkstra: \n");
+  algo_dijkstra(g,g->label);
+  afficher_dijkstra(g);
+
+  printf("\n                                    Degrés sortants des sommets :\n");
+  psommet_t sommet = g;
+  while (sommet != NULL) {
+      int degre_sortant = degre_sortant_sommet(g, sommet);
+      printf("Le degré sortant du sommet %d est : %d\n", sommet->label, degre_sortant);
+      sommet = sommet->sommet_suivant;
+  }
+
+  printf("\n                                    Degrés entrants des sommets :\n");
+  sommet = g;
+  while (sommet != NULL) {
+      int degre_entrant = degre_entrant_sommet(g, sommet);
+      printf("Le degré entrant du sommet %d est : %d\n", sommet->label, degre_entrant);
+      sommet = sommet->sommet_suivant;
+  }
+  printf("\n                                    Degré maximal/minimal :");
+
+  int degre_maximal = degre_maximal_graphe(g);
+  printf("\nLe degré maximal du graphe est : %d\n", degre_maximal);
+
+  int degre_minimal = degre_minimal_graphe(g);
+  printf("Le degré minimal du graphe est : %d\n\n", degre_minimal);
+
+  printf("\n                                  Propriété du graphe :\n");
+
+  printf("Independant? : %s\n", independant(g) ? "OUI" : "NON");
+  printf("Complet ? : %s\n", complet(g) ? "OUI" : "NON");
+  printf("Régulier: %s\n", regulier(g) ? "OUI" : "NON");
+
+
+}
\ No newline at end of file