[Langage C]Arbre n-aire

Premium · Le 20/05/2006, à 15:53

Bonjour,

j'aimerais avoir une aide concernant la création d'un arbre n-aire dont chaque noeud contiendrait une adresse IP

Merci

struct s_IP
{
       char IP[4];// adresse IP
       struct s_IP **tabIP; // tableau des adresse des noeuds associés (tableau dynamique)
}

Dernière modification par Premium (Le 20/05/2006, à 19:23)

YBM · Le 20/05/2006, à 20:30

et où est le problème ?

P.S. tu es obligé de le faire en C ? C'est un projet d'école ou d'université ?

Premium · Le 20/05/2006, à 21:40

YBM a écrit :

et où est le problème ?
P.S. tu es obligé de le faire en C ? C'est un projet d'école ou d'université ?

Salut,

Oui, c'est à écrire en C, c'est une petite partie d'un projet que j'ai à réaliser

J'ai un peu modifié la structure précédente

Avec la structure suivante, j'ai crée une fonction permettant de créer un noeud de l'arbre :

#include <stdio.h>
#include <stdlib.h>

typedef struct node_ip
{
  /* adresse IP */
  unsigned char ip[4];
  
  /* tableau des adresse des noeuds associés */
  struct node_ip **a_nodes;
  
  /* nombre d'elements du tableau */
  size_t nb_elem;
}Node_ip;

typedef Node_ip *Tree;



Tree CreerNode(char ip[4]){
  int i;
  
  Tree tree = (Tree)malloc(sizeof(Node_ip));
  if(tree == NULL){
    perror("erreur allocation");
    exit(1);
  }
  
  for(i=0; i<4; i++)
    tree->ip[i] = ip[i];
  tree->a_nodes = NULL;
  tree->nb_elem = 0;
  
  return tree;
}

Je bloque sur l'insertion et la recherche

Si vous pouviez m'aider?

Merci par avance

YBM · Le 20/05/2006, à 22:42

tu as bien fait, il faut bien savoir combien d'éléments il y a (autre solution : finir le tableau des fils par le pointeur NULL).

Une remarque : il est inutile (et parfois nuisible) de caster le malloc.

Il est impossible de t'aider si tu ne dit pas ce qu'il est entendu par insertion et recherche... Insérer pourquoi pas, mais où et sur quels critère ? Bref, il est pas supposé avoir une propriété particulière ton arbre ?

Premium · Le 20/05/2006, à 22:58

YBM a écrit :

tu as bien fait, il faut bien savoir combien d'éléments il y a (autre solution : finir le tableau des fils par le pointeur NULL).
Une remarque : il est inutile (et parfois nuisible) de caster le malloc.
Il est impossible de t'aider si tu ne dit pas ce qu'il est entendu par insertion et recherche... Insérer pourquoi pas, mais où et sur quels critère ? Bref, il est pas supposé avoir une propriété particulière ton arbre ?

Supposons que mon arbre est le suivant (dans l'exemple chaque sommet à 2 fils mais ça peut être plus)

A - B - C - X
     |    |
     |    H - Z
    E - G - Y

Le noeud "A" contiendra l'adresse du noeud "B"
Le noeud "B" contiendra les adresses des noeuds "C" et "E"
Le noeud "C" contiendra les adresses des noeuds "X" et "H"
etc

Dès qu'on récupère une IP(cette partie a été faite . Toutes les IP qui devront être insérées pour crée l'arbre ont été stockées dans un tableau. Les IP obtenues sont le résultats du parsing de traceroute.
Plusieurs traceroute étant lancés cela donne plusieurs IP donc un sommet donné peut avoir plusieurs fils)

Il faut :
- savoir si elle est présente dans l'arbre => une fonction renvoyant l'adresse du noeud contenant cette IP si elle est présente
- si elle n'est pas présente, on crée un nouveau noeud pour cette IP et on l'insère comme fille du noeud juste avant.

J'espère avoir été clair pour que tu puisses m'aider

YBM · Le 20/05/2006, à 23:09

Le noeud "A" contiendra l'adresse du noeud "B"
Le noeud "B" contiendra les adresses des noeuds "C" et "E"
Le noeud "C" contiendra les adresses des noeuds "X" et "H"

tu veux dire, je pense :
le nœud A a pour fils le nœud B
le nœud B a pour fils les nœuds C et E
le nœud C a pour fils les nœuds X et H

mais dans ce cas ce n'est pas un arbre binaire, donc ça doit pas être ça que tu veux dire...

ton "dessin" est parfaitement illisibles (fait le dans un éditeur à police de chasse fixe avant de le coller ici).

comme tout ça vient d'un traceroute, il n'y a pas moyen de savoir sur la base d'une seule IP où elle doit aller, il faut connaître le nœud où a été insérée l'IP précédente dans la liste du traceroute concernée.

C'est pas très clair tout ça.

YBM · Le 20/05/2006, à 23:19

après réflexion je commence à voir où tu (ils ?) veux(lent) en venir...

pour la recherche : tu n'as pas le choix => recherche exhaustive, avec une fonction récursive c'est pas trop dur à écrire.

pour l'insertition : ta fonction doit nécessairement prendre en argument l'IP du père et l'IP à insérer, si l'IP à insérer existe dans l'arbre il ne faut pas créer de nouveaux noeud mais connecter cette IP à un nouveau père.

Si on ne fait pas ça on va trouver des doublons dans l'arbre (et les branches seront toutes sans bifurcation, ce qui enlève tout intérêt à la représentation...

Mais si on fait ça on va pas avoir un arbre comme résultat, mais un graphe distingué.

Il y a un *gros* problème avec les spécifications du problème si elles parlent d'un arbre...

Et, à la réflexion, c'est pas si simple la recherche, il peut y avoir des boucles...

En tout cas une chose est sûre : la représentation de la sortie d'une suite de traceroute ne peut PAS être un arbre...

Dernière modification par YBM (Le 21/05/2006, à 00:08)

Premium · Le 21/05/2006, à 08:15

YBM a écrit :

après réflexion je commence à voir où tu (ils ?) veux(lent) en venir...
pour la recherche : tu n'as pas le choix => recherche exhaustive, avec une fonction récursive c'est pas trop dur à écrire.
pour l'insertition : ta fonction doit nécessairement prendre en argument l'IP du père et l'IP à insérer, si l'IP à insérer existe dans l'arbre il ne faut pas créer de nouveaux noeud mais connecter cette IP à un nouveau père.
Si on ne fait pas ça on va trouver des doublons dans l'arbre (et les branches seront toutes sans bifurcation, ce qui enlève tout intérêt à la représentation...
Mais si on fait ça on va pas avoir un arbre comme résultat, mais un graphe distingué.
Il y a un *gros* problème avec les spécifications du problème si elles parlent d'un arbre...
Et, à la réflexion, c'est pas si simple la recherche, il peut y avoir des boucles...
En tout cas une chose est sûre : la représentation de la sortie d'une suite de traceroute ne peut PAS être un arbre...

Salut,
J'ai oublié de préciser qu'il faut pour un noeud donné pouvoir accéder à ses fils mais également à son père

je donne un exemple si un traceroute donne ceci pour résultat (les lettres représentent des IP)
traceroute D
A
B
C
D

l'arbre sera le suivant
A-B-C-D

on insère les sommets ainsi que ces fils. Chaque sommet doit pouvoir accéder à son père

si un autre traceroute donne
traceroute D
A
C
B
D

on insère rien dans l'arbre car tous ces sommets sont déjà présents(la notion de chemin différent n'est pas importante dans mon cas)

Ce qui compte est les premiers résultats obtenus puis on ajoute les autres s'ils ne sont pas présents dans l'arbre

Je ne sais pas si je suis clair.

Dernière modification par Premium (Le 22/05/2006, à 12:09)

YBM · Le 21/05/2006, à 12:58

on insère rien dans l'arbre car tous ces sommets sont déjà présents(la notion de chemin différent n'est pas importante dans mon cas)

Donc l'arbre représente toutes les IPs, mais une seulement une partie des chemins ?

si on a A-B-C-D dans un premier traceroute et A-E-F-D dans un second ? On est supposé obtenir ça ?

C'est à dire que le second traceroute ajoute des IPs dans l'arbre mais PAS l'intégralité du chemin correspondant ?

(si c'est vrai j'aimerai bien dire deux mots au prof. qui a proposé ce projet...)

J'ai oublié de préciser qu'il faut pour un noeud donné pouvoir accéder à ses fils mais également à son père

Il faut donc ajouter un champ dans ta structure : un pointeur vers le père.

Dernière modification par YBM (Le 21/05/2006, à 12:58)

Premium · Le 21/05/2006, à 15:08

Salut,

je me suis trompé.
En faite dans le cas que tu as pris cela donnerait :

    A
    | \
    E  B
    |   |
    F  C
    |   |
    D  D

Il faut donc ajouter D

Dernière modification par Premium (Le 21/05/2006, à 15:12)

YBM · Le 21/05/2006, à 15:51

tu veux dire que la même IP est présente 2 fois dans l'arbre ?!

et que donc... sauf A *tous* les nœuds n'auront au plus qu'un fils.

c'est encore plus débile...

Premium · Le 21/05/2006, à 16:46

YBM a écrit :

tu veux dire que la même IP est présente 2 fois dans l'arbre ?!
et que donc... sauf A *tous* les nœuds n'auront au plus qu'un fils.
c'est encore plus débile...

Si un premier traceroute donne A-B-C-D
Un deuxième donne A-E-F-D
Un troisième A-B-F-D
Un quatrième donne A-E-F-H
Un cinqueme A-D

Un traceroute peut donner des résultats différents d'une minute à l'autre

on aurait cet arbre : un sommet peut donc avoir plus d'un fils

A-------
| \ |
E B D
| |
F C
/ | |
H D D

Il y est possible qu'un même sommet soit présent dans plusieurs fils : c'est le cas de D

Dernière modification par Premium (Le 21/05/2006, à 17:49)

YBM · Le 21/05/2006, à 17:04

c'est complètement incohérent... si tu dois dans le dernier arbre ci-dessus traité un traceroute ...-D-G, le "G" tu le mets où ? à la suite de quel D ?

Premium · Le 21/05/2006, à 17:18

YBM a écrit :

c'est complètement incohérent... si tu dois dans le dernier arbre ci-dessus traité un traceroute ...-D-G, le "G" tu le mets où ? à la suite de quel D ?

En effet, ce cas pose problème : la structure est inadaptée

Que proposerais-tu pour pouvoir représenter les résultats des différents traceroute?

YBM · Le 21/05/2006, à 17:40

un graphe distingué (A est le noeud de "départ" du graphe)

avec une structure de pointeur :

pour chaque noeud :
- l'adresse IP (unique dans le graphe)
- un tableau de pointeur vers les successeurs

on peut aussi représenter ça par une matrice : tu tries tes IP, et la valeur de link[i][j] vaut 1 si il y a un succession de l'IP n° i à l'IP n° j dans un des traceroutes, 0 sinon.
(s'il y a beaucoup d'IP, ça va faire une matrice assez creuse, on peut aussi représenter ça par la liste des (i,j) tq link[i][j]=1)

Premium · Le 21/05/2006, à 17:48

Ce que j'ai écris fonctionne dans le cas de sommet numérotés entre 0 et size-1

Le problème est dans le cas de la fonction :

void addEdge(Graphe *g, int source, int dest){
 g->adj[source] = consListe(dest, g->adj[source]);
}

ce ne sera pas possible de prendre les sommets ip_source et ip_dest de type adresse_ip et les considérer comme des indices d'un tableau.

#include <stdio.h>
#include <stdlib.h>


typedef struct cellule{
  int val;
  struct cellule *next;
}Cellule;
typedef Cellule *Liste;



typedef struct graphe{
  int size;
  Liste *adj;
}Graphe;



Cellule *CreerCellule(int val){
  Cellule *c = (Cellule*)malloc(sizeof(Cellule));
  if(c == NULL)
    return NULL;
  
  c->val = val;
  c->next = NULL;
  
  return c;
}


Liste consListe(int val, Liste liste)
{
  Liste parcours ;
  Cellule* c = CreerCellule(val);
  
  if (!c) return NULL ;
  
  if ( liste == NULL )
    {
      c->next = NULL ; 
      return c ;
    }
  
  for(parcours=liste; parcours->next; parcours=parcours->next ) ;
  
  parcours->next = c ;
  return liste;
}


Graphe *consGraph(int size){
  int i;
  
  Graphe *g = (Graphe*)malloc(sizeof(Graphe));
  if(g == NULL)
    return NULL;
  
  g->size = size;
  
  if(size > 0)
    g->adj = (Liste*)malloc(size*sizeof(Liste));
  else
    g->adj = NULL;
  
  for(i=0; i<size; i++)
    g->adj[i] = NULL;
  
  return g;
}

void addEdge(Graphe *g, int source, int dest){
  g->adj[source] = consListe(dest, g->adj[source]);
}

int main(void)
{
  int i ; Liste parcours ;
  Graphe *g = NULL;
  g = consGraph(3);
  
  addEdge(g,0,1);
  addEdge(g,0,2);
  addEdge(g,1,2);
  
  for( i=0; i<g->size; i++ )
    {
      printf( "Sommet %d :", i );
      for( parcours=g->adj[i]; parcours; parcours=parcours->next )
	printf( " %d", parcours->val ) ;
      printf ("\n" ) ;
    }
  return 0;
}

EDit : ça correspond à ce que tu proposes ?

Dernière modification par Premium (Le 21/05/2006, à 17:56)

YBM · Le 21/05/2006, à 17:57

Je comprends pas pourquoi tu as besoin de définir plus d'une structure (un nœud du graphe)...

Tu as bien remarqué, je pense, qu'il faut parcourir totalement le graphe jusqu'à trouver une IP déjà présente (ou être sûre qu'elle n'y est pas déjà), et donc qu'il faut étiqueter les nœuds lors de ce parcours (pour ne pas tourner en rond !).

P.S. il est toujours inutile de caster les mallocs

Premium · Le 21/05/2006, à 18:05

YBM a écrit :

Je comprends pas pourquoi tu as besoin de définir plus d'une structure (un nœud du graphe)...

Ce que tu veux dire, c'est que la structure que j'appelle Liste est en faite le graphe et que je n'ai pas besoin de creer la structure graphe ?

Tu as bien remarqué, je pense, qu'il faut parcourir totalement le graphe jusqu'à trouver une IP déjà présente (ou être sûre qu'elle n'y est pas déjà), et donc qu'il faut étiqueter les nœuds lors de ce parcours (pour ne pas tourner en rond !).
P.S. il est toujours inutile de caster les mallocs

Je comprends très bien ce que tu veux dire ni comment tu accedes au sommet du graphe

YBM · Le 21/05/2006, à 18:17

Cellule = une structure avec dedans l'adresse IP, le nombre de "successeurs" et la liste des pointeurs vers les successeurs (des pointeurs vers d'autres Cellule).

Le graphe n'a pas vraiment de sommet, mais une cellule distinguée qui représentera A dans ton cas, et qui va servir de point de départ pour parcourir le graphe.

Pour faire une recherche, il faut construire une liste des IPs des Cellules déjà rencontrées au fur et à mesure, pour éviter de repasser par des Cellules déjà examinées.

Premium · Le 21/05/2006, à 22:37

Salut,
alors je me suis crée de nouvelle structure que je comprends mieux

typedef struct cellule{
  int val;
  struct cellule *next;
}Cellule;
typedef Cellule *Liste;


typedef struct
{
  unsigned char ip[4];
  Liste *voisin; 
}NoeudIp;

typedef struct{
  int size;
  NoeudIp *tab;
}GrapheIP;

Je fais un tableau de NoeudIp (tableau = accessible par indiçage) que je met dans une structure graphe.

J'ai crée un algo pour l'ajout :

insereApres(unsigned char *cetteip[4], Tree *nouveauNoeud)
// nouveauNoeud: le noeud que l'on veut inserer dans l'arbre
// cetteip: on insere nouveauNoeud comme fils de cetteip
// -> il faut donc rechercher cette ip dans notre tableau et une fois trouve, rajoute nouveauNoeud dans la partie a_nodes Du Node_ip correspondant.
{
     // en language algorithmique  :
     trouve = FALSE;
     pour i de 1 à derniernoeud
          si estEgal(tableaunoeud[i].ip, ip) alors
               trouve = TRUE;
               ajouteA(tableaunoeud[i].a_nodes, nouveauNoeud);
                
               quitter boucle pour;
          finsi
     finpour     
     si trouve == FALSE
          "adresse ip non trouvée"
     sinon
          // nouveauNoeud doit aussi etre rajouté a notre tableau de noeud:
          tableaunoeud[derniernoeud+1]=nouveauNoeud;
          derniernoeud=derniernoeud+1;
     finsi.        
}

.
Le problème est que je n'arrive pas à l'adapter aux fonctions que j'ai écrit plus haut.

Si quelqu'un pouvait m'aider s'il vous plait car j'essaye mais je n'y arrive pas ?

Merci d'avance

Dernière modification par Premium (Le 21/05/2006, à 22:44)

YBM · Le 21/05/2006, à 23:55

Tu fais un tableau d'IP d'un côté et une structure chaînée de l'autre c'est ça ?

Ça peut marcher, mais ça me paraît un peu tordu...

C'est vraiment un sujet de fac/école ce truc ?

Premium · Le 22/05/2006, à 07:09

YBM a écrit :

Tu fais un tableau d'IP d'un côté et une structure chaînée de l'autre c'est ça ?
Ça peut marcher, mais ça me paraît un peu tordu...

Tu avais écrit ceci :

Cellule = une structure avec dedans l'adresse IP, le nombre de "successeurs" et la liste des pointeurs vers les successeurs (des pointeurs vers d'autres Cellule).
Le graphe n'a pas vraiment de sommet, mais une cellule distinguée qui représentera A dans ton cas, et qui va servir de point de départ pour parcourir le graphe.
Pour faire une recherche, il faut construire une liste des IPs des Cellules déjà rencontrées au fur et à mesure, pour éviter de repasser par des Cellules déjà examinées.

Je ne vois pas très bien comment s'utiliserait cela?
Est-ce qur tu pourrais m'écrire les structures auxquelles tu penses ? ainsi que le pseudo-code pour la recherche car je tourne en rond et n'arrive à rien?
Merci

C'est vraiment un sujet de fac/école ce truc ?

Oui, il faut que le code écrit soit le plus cohérent possible ce qui n'est pas mon cas

Dernière modification par Premium (Le 22/05/2006, à 07:10)

YBM · Le 22/05/2006, à 09:16

Tu devrais poster le sujet exact, parce que là ça part dans dans tous les sens (et on a jeté par la fenêtre des points comme "il faut pour un noeud donné pouvoir accéder à ses fils mais également à son père", qui ne sont pas très cohérents avec le reste).

Il y a trois aspects qu'il faudrait bien séparer (surtout pour obtenir de l'aide sur un forum) : la représentation des données, l'algorithmique, le codage effectif en C.

Premium · Le 22/05/2006, à 12:08

Salut, voici l'énonce du projet :
C'est la partie graphe qui me pose problème

Le réseau Internet peut être grossièrement assimilé à un graphe, dont les noeuds sont les hôtes (machines, routeurs...) et les arêtes les liens entre ces hôtes. Depuis un noeud A donné, il est très difficile d'avoir une vue d'ensemble du réseau ; cependant, on peut effectuer un « traceroute » vers un autre noeud B, et dans la plupart des cas, obtenir une liste de noeuds formant un chemin entre A et B.

Sur Internet, une machine (ou un routeur, c'est pareil!) peut avoir 1 ou plusieurs adresses IP, et chaque adresse IP peut avoir 0, 1 ou plusieurs noms DNS rattachés. Inversement, un nom DNS peut être rattaché à 0, 1 ou plusieurs adresses IP. Comme les relations entre les adresses IP et les noms DNS sont complexes, on ignorera complètement les noms DNS. D'autre part, même si une machine peut avoir plusieurs adresses IP, on n'essaiera pas de « deviner » si plusieurs adresses appartiennent à la même machine ou pas. On raisonnera donc, finalement, en adresses IP plutôt qu'en machines ou routeurs ou noms DNS.
L'option -n de la commande traceroute permet de désactiver la résolution DNS (la conversion des adresses IP en noms)
~traceroute -n 192.48.96.9
traceroute to 192.48.96.9 (192.48.96.9), 30 hops max, 40 byte packets
 1  192.168.0.1  9.754 ms  9.461 ms  8.046 ms
 2  195.6.244.14  60.885 ms  48.924 ms  90.517 ms
 3  194.206.126.244  50.503 ms  48.97 ms  120.122 ms
 4  194.206.126.2  55.655 ms  52.213 ms  58.908 ms
 5  208.213.229.130  588.303 ms  589.843 ms  589.611 ms
 6  208.213.229.129  599.564 ms  599.763 ms  600.749 ms
 7  208.213.229.226  629.167 ms  599.284 ms  599.383 ms
 8  195.10.40.34  599.152 ms  599.289 ms  631.011 ms
 9  157.130.34.217  642.326 ms  715.072 ms  653.724 ms
10  146.188.160.62  595.143 ms  590.433 ms  659.247 ms
11  146.188.160.181  649.863 ms  700.901 ms  617.067 ms
12  137.39.253.86  600.835 ms  599.379 ms  590.867 ms
13  192.48.96.9  607.071 ms  589.221 ms  603.156 ms
Attention, le graphe d'Internet n'est pas forcément un graphe « idéal », et les chemins que vous verrez apparaître en faisant des « traceroute » ne seront pas forcément les meilleurs ou les plus courts. Ne vous étonnez pas si par exemple, sur un traceroute, vous voyez des chemins non-optimaux !
D'autre part, ce n'est pas non plus un graphe figé ni déterministe, donc d'un jour à l'autre (ou même d'une minute à l'autre) un même traceroute pourra donner des résultats différents.
But du projet
Il s'agit d'écrire un programme (ou un ensemble de programmes) permettant d'effectuer des traceroute automatiquement, en tâche de fond ; et pendant que se font ces traceroute, de rassembler des informations sur le graphe d'Internet. En particulier, pour chaque noeud du graphe (on assimilera un noeud à son adresse IP), on souhaite pouvoir connaître ses voisins, ainsi que sa distance minimale à l' « origine » (la distance n'est pas forcément constante, par exemple entre le noeud A et le noeud B, le noeud X peut apparaître en 5è position ; et le même noeud X peut apparaître en 8è position entre le noeud A et le noeud C -- c'est surprenant, mais c'est possible!).
Il est indispensable de pouvoir :
* avoir plusieurs traceroute s'effectuant simultanément, afin de rassembler des informations le plus vite possible ;
* pouvoir choisir à la volée combien de traceroute on souhaite exécuter en parallèle) ;
* ajouter de nouvelles « cibles » pour traceroute pendant que l'ensemble fonctionne ;
* ajouter des cibles « aléatoires » (en tirant des adresses IP au hasard) ;
* visualiser des statistiques indiquant le nombre d'adresses IP « explorées » (nombre total, et classement par distance par rapport à l'origine) ;
* indiquer les « voisins » d'un noeud donné par son adresse IP ;
* exporter (et importer) l'état du graphe, sous forme de deux fichiers CSV : un contenant la liste des sommets (adresses IP) avec leur distance minimale à la source, et un autre contenant une liste de couples d'adresses IP ;

Informations techniques
Une adresse IP = 4 octets. Généralement on la représente sous la forme 134.157.0.129 (sous forme de 4 nombres entiers, en décimal, séparés par des points).
Les plages d'adresses suivantes sont « privées », c'est-à-dire internes :
* 10.0.0.0 à 10.255.255.255
* 172.16.0.0 à 172.31.255.255
* 192.168.0.0 à 192.168.255.255
La plage 224.0.0.0 à 239.255.255.255 est réservée au multicast.
Les adresses de 240.0.0.0 à 255.255.255.255 sont réservées.
Toutes ces plages (adresses privées, multicast, réservées) ne doivent pas être traitées
Le format CSV à utiliser, pour la liste des noeuds : adresse IP, distance
1.2.3.4,17
134.157.0.129,8
193.55.63.92,2
Le format CSV à utiliser, pour la liste des arêtes : adresse IP1, adresse IP2
1.2.3.4,1.2.3.5
134.157.0.129,134.157.254.1
193.55.63.1,193.55.63.29
On utilisera \n comme séparateur de lignes.

YBM · Le 22/05/2006, à 18:35

Ok, c'est bien un graphe que tu dois représenter.

Effectivement tu peux le faire en représentant les noeuds par une structure contenant l'IP et les voisins par un pointeur vers eux (et il faudrait mettre un pointeur dans les deux sens, puisque une route est toujours bidirectionnelle, sinon chopper les voisins va pas être commode.

L'autre solution, que je choisirais personnellement est une matrice (une demi matrice plus précisément puisque tu sais à l'avance qu'elle est symétrique). Comme la taille peut changer en cours d'exécution et que elle va être plutôt creuse il vaut mieux la stocker sous la forme de la liste chaînée des éléments non-nul : (ip1,ip2). Pour faire super-pro plutôt qu'une liste chaînée une table de hâchage donnerait des temps de recherche plus courts, mais je ne crois pas que ça vaille le coup ici.

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#1 Le 20/05/2006, à 15:53

[Langage C]Arbre n-aire

#2 Le 20/05/2006, à 20:30

Re : [Langage C]Arbre n-aire

#3 Le 20/05/2006, à 21:40

Re : [Langage C]Arbre n-aire

#4 Le 20/05/2006, à 22:42

Re : [Langage C]Arbre n-aire

#5 Le 20/05/2006, à 22:58

Re : [Langage C]Arbre n-aire

#6 Le 20/05/2006, à 23:09

Re : [Langage C]Arbre n-aire

#7 Le 20/05/2006, à 23:19

Re : [Langage C]Arbre n-aire

#8 Le 21/05/2006, à 08:15

Re : [Langage C]Arbre n-aire

#9 Le 21/05/2006, à 12:58

Re : [Langage C]Arbre n-aire

#10 Le 21/05/2006, à 15:08

Re : [Langage C]Arbre n-aire

#11 Le 21/05/2006, à 15:51

Re : [Langage C]Arbre n-aire

#12 Le 21/05/2006, à 16:46

Re : [Langage C]Arbre n-aire

#13 Le 21/05/2006, à 17:04

Re : [Langage C]Arbre n-aire

#14 Le 21/05/2006, à 17:18

Re : [Langage C]Arbre n-aire

#15 Le 21/05/2006, à 17:40

Re : [Langage C]Arbre n-aire

#16 Le 21/05/2006, à 17:48

Re : [Langage C]Arbre n-aire

#17 Le 21/05/2006, à 17:57

Re : [Langage C]Arbre n-aire

#18 Le 21/05/2006, à 18:05

Re : [Langage C]Arbre n-aire

#19 Le 21/05/2006, à 18:17

Re : [Langage C]Arbre n-aire

#20 Le 21/05/2006, à 22:37

Re : [Langage C]Arbre n-aire

#21 Le 21/05/2006, à 23:55

Re : [Langage C]Arbre n-aire

#22 Le 22/05/2006, à 07:09

Re : [Langage C]Arbre n-aire

#23 Le 22/05/2006, à 09:16

Re : [Langage C]Arbre n-aire

#24 Le 22/05/2006, à 12:08

Re : [Langage C]Arbre n-aire

#25 Le 22/05/2006, à 18:35

Re : [Langage C]Arbre n-aire

Pied de page des forums