Skip to content
Snippets Groups Projects
Commit 3f780733 authored by Nicolas Floquet's avatar Nicolas Floquet
Browse files

Commit liste_url avec assert

parents 4bebfbe3 d890a4f1
No related branches found
No related tags found
1 merge request!12Floquet nicolas graphe v01
Hide whitespace changes
Inline Side-by-side
pagerank/src/pagerank.c deleted 100644 → 0
+ 0
− 316
View file @ 4bebfbe3
#include <stdio.h>
#include <stdlib.h>
#include "pagerank.h"
#include "graphe.h"
#include "liste_url.h"
/** Fonction qui crée un pagerank pour n URLs qui est stocké à l'adresse donnée en argument, déjà allouée,
* @param p un pagerank alloué en mémoire
* @param n un entier strictement positif, la taille du graphe et de la liste du pagerank
* @return 0 si la liste a été créée et -1 si n <= 0 et -2 s'il y a eu une erreur d'allocation
* O(n)
*/
int creer_pagerank(pagerank* p, int n)
{
if(n <= 0)
{
printf("Erreur paramètre creer_pagerank, n <= 0\n");
return -1;
}
if(!(p->g = (graphe*) malloc(sizeof(graphe))))
{
printf("Erreur allocation creer_pagerank, malloc p->g\n");
return -2;
}
if(creer_graphe(p->g, n))
{
free(p->g);
printf("Erreur allocation creer_pagerank, creer_graphe\n");
return -2;
}
if(!(p->l = (liste_url*) malloc(sizeof(liste_url))))
{
graphe_detruire(p->g);
free(p->g);
printf("Erreur allocation creer_pagerank, malloc p->l\n");
return -2;
}
if(creer_liste(p->l, n))
{
graphe_detruire(p->g);
free(p->g);
free(p->l);
printf("Erreur allocation creer_pagerank, creer_liste\n");
return -2;
}
return 0;
}
/** Libère la mémoire allouée dans un pagerank
* @param p un pagerank alloué en mémoire
* O(n)
*/
void pagerank_detruire(pagerank* p)
{
if(p)
{
if(p->g)
{
graphe_detruire(p->g);
free(p->g);
p->g = NULL;
}
if(p->l)
{
liste_detruire(p->l);
free(p->l);
p->l = NULL;
}
}
}
/** Donne l'indice d'une url est dans la liste d'un pagerank
* @param p un pagerank alloué en mémoire
* @param s une chaîne, l'URL dont on veut connaître l'indice dans la liste
* @return l'indice de l'URL si elle est dans la liste du pagerank et -1 sinon
* O(n)
*/
int pagerank_find_indice_URL(pagerank* p, char* s)
{
if(p)
{
return liste_find(p->l, s);
}
return -1;
}
/** Renvoie l'url à l'indice i dans la liste d'un pagerank
* @param p un pagerank alloué en mémoire
* @param i un entier
* @return p->l->urls[i] une chaîne de caractères si 0 <= i < liste_get_max(l), NULL sinon
* O(1)
*/
char* pagerank_get_URL_i(pagerank* p, int i)
{
if(p)
{
return liste_get_i(p->l, i);
}
return NULL;
}
/** Ajoute une URL à la première case vide dans la liste
* @param p un pagerank alloué en mémoire
* @param s une chaîne, l'URL à ajouter
* O(1)
*/
void pagerank_add_URL(pagerank* p, char* s)
{
if(p && p->l)
{
liste_add(p->l, s);
}
}
/** Retire une URL du pagerank en retirant le sommet de son graphe, et l'URL de sa liste
* @param p un pagerank alloué en mémoire
* @param s une chaîne, l'URL à retirer
* O(n)
*/
void pagerank_remove_URL(pagerank* p, char* s)
{
if(p && p->l && p->g)
{
int x = liste_find(p->l, s);
if(x != -1)
{
liste_remove(p->l, s);
graphe_retirer_sommet(p->g, x);
}
}
}
/** Relie 2 URLs du pagerank
* @param p un pagerank alloué en mémoire
* @param s1 une des URLs du pagerank
* @param s2 une des URLs du pagerank
* O(n)
*/
void pagerank_relier_URL(pagerank* p, char* s1, char* s2)
{
if(p && p->l && p->g)
{
printf("ici pour %s et %s\n", s1, s2);
if(liste_contains(p->l, s1) && liste_contains(p->l, s2))
{
printf("la pour %s et %s\n", s1, s2);
graphe_ajouter_arete(p->g, liste_find(p->l, s1), liste_find(p->l, s2));
}
}
}
/** Delie 2 URLs en retirant une arête entre les sommets correspondant du graphe du pagerank s'il y en a une
* @param p un pagerank alloué en mémoire
* @param s1 une des URLs du pagerank
* @param s2 une des URLs du pagerank
* O(n)
*/
void pagerank_delier_URL(pagerank* p, char* s1, char* s2)
{
if(p && p->l && p->g)
{
if(liste_contains(p->l, s1) && liste_contains(p->l, s2))
{
graphe_supprimer_arete(p->g, liste_find(p->l, s1), liste_find(p->l, s2));
}
}
}
/** Indique si une URL dans le pagerank a un lien vers une autre URL
* @param p un pagerank alloué en mémoire
* @param s1 une chaîne, l'URL où peut être le lien qu'on cherche
* @param s2 une chaîne, l'URL cible
* @return 1 si il y a un lien vers s2 dans la page s1 et 0 sinon
* O(n)
*/
int pagerank_link_to(pagerank* p, char* s1, char* s2)
{
if(p && s1 && s2)
{
int indice1 = pagerank_find_indice_URL(p, s1);
int indice2 = pagerank_find_indice_URL(p, s2);
return graphe_est_succ(p->g, indice1, indice2);
}
return 0;
}
/** Affiche le pagerank (le graphe et la liste)
* @param p un pagerank alloué en mémoire
* O(n)
*/
void pagerank_afficher(pagerank* p)
{
if(p)
{
printf("Voici la liste du pagerank:\n\n");
liste_afficher(p->l);
printf("Voici le graphe du pagerank sous la forme de ces tableaux (matrice creuse):\n\n");
graphe_afficher_tableaux(p->g);
printf("Voici le graphe du pagerank sous la forme d'une matrice d'adjacence:\n\n");
graphe_afficher(p->g);
}
else
{
printf("Le pagerank est NULL\n");
}
}
/** Convertit le graphe d'un pagerank au format DOT dans un fichier
* On verra un graphe avec comme sommets les URLs
* dot -Tpdf fichier.dot -o fichier.pdf
* @param p un pagerank alloué en mémoire
* @param nomFichier, le nom du fichier où l'on veut écrire le graphe
* @return 0 si le graphe a bien été écris au format DOT,
* -1 s'il y a eu une erreur d'ouverture du fichier, et -2 sinon
* O(n)
*/
int pagerank_ecrire_dot(pagerank* p, char* nomFichier)
{
if(p)
{
int i, nbSommets = 0, n = graphe_get_premier_vide(p->g), sommetMax = graphe_get_plus_grand_sommet(p->g);
if(!n)
{
printf("Erreur premier vide = 0, graphe vide pagerank_ecrire_dot\n");
return -2;
}
/*
On utilise 2 tableaux pour avoir une liste des sommets dans le graphe.
Soit n = graphe_get_premier_vide(g), il y a au max 2n sommets différents
(Si tous les sommets dans le tableau des lignes sont distincts et pointent chacun vers un sommet distinct)
Donc c'est le nombre max de sommets dans le fichier DOT.
Et les valeurs des sommets sont entre 0 et graphe_get_plus_grand_sommet(g) inclus
*/
int* flagSommet = (int *) calloc(sizeof(int), sommetMax + 1);
/*
flagSommet[i] =
0 : sommet pas dans le graphe
1 : sommet dans le graphe, il faudra l'ajouter dans le fichier dot
Toutes les valeurs entières entre 0 et sommetMax inclus peuvent être dans le graphe
*/
if(!flagSommet)
{
printf("Erreur allocation flagSommet pagerank_ecrire_dot\n");
return -2;
}
int* listeSommets = (int *) calloc(sizeof(int), 2*n);
/*
listeSommets[i] :
-1 : sommet pas dans le graphe
>= 0 : sommet dans le graphe, il faudra l'ajouter dans le fichier dot
Il y a au max 2n sommets différents
*/
if(!listeSommets)
{
printf("Erreur allocation listeSommets pagerank_ecrire_dot\n");
free(flagSommet);
return -2;
}
for(i = 0; i < 2*n; i++)
{
listeSommets[i]--; //-1 partout
}
FILE *f = fopen(nomFichier, "w");
if (!f)
{
free(flagSommet);
free(listeSommets);
printf("Erreur ouverture fichier \"%s\"pagerank_ecrire_dot\n", nomFichier);
return -1;
}
for(i = 0; i < n; i++)
{
if(!flagSommet[p->g->ligne[i]]) //g->ligne[i] valait 0, donc le sommet n'était pas découvert
{
flagSommet[p->g->ligne[i]] = 1;
listeSommets[nbSommets++] = p->g->ligne[i];
}
if(!flagSommet[p->g->col[i]]) //g->col[i] valait 0, donc le sommet n'était pas découvert
{
flagSommet[p->g->col[i]] = 1;
listeSommets[nbSommets++] = p->g->col[i];
}
}
//Dans flagSommet, on a tous les flags indiquant si un sommet est dans le graphe ou non
//Dans listeSommets on a la liste des sommets distincts
fputs("graph {\n", f);
for(i = 0; i < nbSommets; i++)
{
fprintf(f, "\t\"%s\";\n", liste_get_i(p->l, listeSommets[i]));
}
fputs("\n", f);
for(i = 0; i < n; i++)
{
fprintf(f, "\t\"%s\" -- \"%s\";\n", liste_get_i(p->l, p->g->ligne[i]), liste_get_i(p->l, p->g->col[i]));
}
fputs("}\n", f);
free(flagSommet);
free(listeSommets);
fclose(f);
return 0;
}
printf("Erreur pagerank NULL pagerank_ecrire_dot\n");
return -2;
}
pagerank/src/pagerank.h deleted 100644 → 0
+ 0
− 111
View file @ 4bebfbe3
#ifndef PAGERANK_H
#define PAGERANK_H
#include "graphe.h"
#include "liste_url.h"
struct s_pagerank {
graphe* g; //Le graphe du pagerank
liste_url* l; //La liste de toutes les URLs du pagerank
};
typedef struct s_pagerank pagerank;
/** Fonction qui crée un pagerank pour n URLs qui est stocké à l'adresse donnée en argument, déjà allouée,
* @param p un pagerank alloué en mémoire
* @param n un entier strictement positif, la taille du graphe et de la liste du pagerank
* @return 0 si la liste a été créée et -1 si n <= 0 et -2 s'il y a eu une erreur d'allocation
* O(n)
*/
int creer_pagerank(pagerank* p, int n);
/** Libère la mémoire allouée dans un pagerank
* @param p un pagerank alloué en mémoire
* O(n)
*/
void pagerank_detruire(pagerank* p);
/** Donne l'indice d'une url est dans la liste d'un pagerank
* @param p un pagerank alloué en mémoire
* @param s une chaîne, l'URL dont on veut connaître l'indice dans la liste
* @return l'indice de l'URL si elle est dans la liste du pagerank et -1 sinon
* O(n)
*/
int pagerank_find_indice_URL(pagerank* p, char* s);
/** Renvoie l'url à l'indice i dans la liste d'un pagerank
* @param p un pagerank alloué en mémoire
* @param i un entier
* @return p->l->urls[i] une chaîne de caractères si 0 <= i < liste_get_max(l), NULL sinon
* O(1)
*/
char* pagerank_get_URL_i(pagerank* p, int i);
/** Ajoute une URL à la première case vide dans la liste
* @param p un pagerank alloué en mémoire
* @param s une chaîne, l'URL à ajouter
* O(1)
*/
void pagerank_add_URL(pagerank* p, char* s);
/** Retire une URL du pagerank en retirant le sommet de son graphe, et l'URL de sa liste
* @param p un pagerank alloué en mémoire
* @param s une chaîne, l'URL à retirer
* O(n)
*/
void pagerank_remove_URL(pagerank* p, char* s);
/** Relie 2 URLs du pagerank
* @param p un pagerank alloué en mémoire
* @param s1 une des URLs du pagerank
* @param s2 une des URLs du pagerank
* O(n)
*/
void pagerank_relier_URL(pagerank* p, char* s1, char* s2);
/** Delie 2 URLs en retirant une arête entre les sommets correspondant du graphe du pagerank s'il y en a une
* @param p un pagerank alloué en mémoire
* @param s1 une des URLs du pagerank
* @param s2 une des URLs du pagerank
* O(n)
*/
void pagerank_delier_URL(pagerank* p, char* s1, char* s2);
/** Indique si une URL dans le pagerank a un lien vers une autre URL
* @param p un pagerank alloué en mémoire
* @param s1 une chaîne, l'URL où peut être le lien qu'on cherche
* @param s2 une chaîne, l'URL cible
* @return 1 si il y a un lien vers s2 dans la page s1 et 0 sinon
* O(n)
*/
int pagerank_link_to(pagerank* p, char* s1, char* s2);
/** Affiche le pagerank (le graphe et la liste)
* @param p un pagerank alloué en mémoire
* O(n)
*/
void pagerank_afficher(pagerank* p);
/** Convertit le graphe d'un pagerank au format DOT dans un fichier
* @param p un pagerank alloué en mémoire
* @param nomFichier, le nom du fichier où l'on veut écrire le graphe
* @return 0 si le graphe a bien été écris au format DOT,
* -1 s'il y a eu une erreur d'ouverture du fichier, et -2 sinon
* O(n)
*/
int pagerank_ecrire_dot(pagerank* p, char* nomFichier);
//int pagerank isValid test indices
#endif
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment