1. Fonctions

Jonas TERMEAU
Vivien OUAIRY
Dossier Graphe
Algorithmes du programme
1. Fonctions ----------------------------------------------------------------------------------- 2
1.1. Parcours en profondeur -------------------------------------------------------------- 2
1.2. Parcours en largeur ------------------------------------------------------------------- 3
1.3. Composantes connexes -------------------------------------------------------------- 4
1.4. Dijkstra --------------------------------------------------------------------------------- 5
2. Jeux d’essais ------------------------------------------------------------------------------ 7
2.1. Graphes utilisé : ----------------------------------------------------------------------- 7
2.2. Résultats : ----------------------------------------------------------------------------- 7
2.2.1. Parcours en largeur : (sommet de départ : 1) ------------------------------------- 7
2.2.2. Parcours en profondeur : (sommet de départ : 1) ------------------------------- 7
2.2.3. Composantes connexes : (sommet de départ : 1) -------------------------------- 7
Septembre 2007
Info 2 Groupe 2
1. Fonctions
1.1. Parcours en profondeur
Pour faire le parcours en profondeur, on utilise la pile. Le fichier pile.h est joint
au projet.
Algorithme :
initialiser(pile) ;
empiler(sommet_départ,Pile) ;
enlever_marque(graphe) ;
tant que vide(Pile)=faux faire
sommet = dépiler(Pile) ;
pour i de 0 à taille_graphe faire
si adjacent(sommet_précédent)=vrai et non-marquer (sommet)
= vrai alors
empiler(sommet suivant) ;
démarquer(sommet) ;
fin si ;
i = i+1 ;
fin pour ;
fin tant que ;
2
1.2. Parcours en largeur
projet.
Pour faire les parcours en largeur, on utilise la file. Le fichier file.h est joint au
Algorithme :
initialiser(file) ;
enfiler(sommet_départ,file) ;
enlever_marque(graphe) ;
/*fonction pour enlever tous les
marquages*/
marquer(sommet_départ) ;
tant que filevide(file)=faux faire
sommet = défiler(file) ;
pour i de 0 à taille_graphe faire
si adjacent(sommet_précédent)=vrai et non-marquer(sommet)=
vrai alors
enfiler(sommet suivant) ;
démarquer(sommet) ;
fin si ;
i = i+1 ;
fin pour ;
fin tant que ;
3
1.3. Composantes connexes
Algorithme :
nb_composante = 1 ;
nb_sommet_marqués=0 ;
tant que marquer(i) = 0 faire
i=i+1 ;
//on prends le premier non marquer
parcours_largeur(i+1) ;
pour i de 0 à
taille_graphe faire
si marquer(sommet) == vrai et déjà_parouru(sommet)==faux
alors
déjà_parcouru(sommet)=vrai ;
nb_sommet_marqués = nb_sommets_marqués +1 ;
fin si ;
i = i+1 ;
fin pour ;
fin tant que ;
4
1.4. Dijkstra
Algorithme :
entier infini = 99999999 ;
tableau tableau[taille_graphe] ;
entier nonMarquer=1 ;
entier sommet_actuel ;
plusgrand = infini +1 ;
enlever_marque(graphe) ;
mettre_infini(tableau) ;
démarque(graphe) ;
tableau(sommet_départ_choisi) = 0 ;
tant que nonMarquer = 1 faire
nonMarquer =0
pour i de 0 à taille_graphe faire
si plusGrand>tableau[i] et marquer(i)=faux faire
sommetactuel = i ;
plusgrand = tableau[i] ;
fin si ;
fin pour ;
plusgrand = inf + 1 ;
démarquer(sommet_actuel) ;
pour i de 0 à taille_graphe faire
si adjacent[sommet_actuel] alors
si marquer(i) alors
si tableau[i] > tableau[sommet_actuel] +
graphe[sommet_actuel][i] alors
tableau[i] = tableau[sommet_actuel] +
graphe[sommet_actuel][i]
fin si ;
fin si ;
fin si ;
i=i+1
fin pour ;
pour i de 0 à taille_graphe faire
si marquer[i]=vrai alors
nonMarquer = 1 ;
fin si ;
5
i=i+1 ;
fin pour ;
fin tant que ;
6
2. Jeux d’essais
2.1. Graphes utilisé :
GRAPHE G
4
5
8
1
7
2
9
6
3
2.2. Résultats :
2.2.1. Parcours en largeur : (sommet de départ : 1)
1, 2, 3
2.2.2. Parcours en profondeur : (sommet de départ : 1)
1, 2, 3
2.2.3. Composantes connexes : (sommet de départ : 1)
1 2 3
4 5 7 6
8 9
7