Langage C: liste chainee

typedef struct noeud noeud;
struct noeud
{
    int numero;
    double abscisse;
    double ordonee;
    
    struct noeud *suivant;
};
typedef noeud* llist;

double * calculer_distance_entre_sommets(noeud *p1, noeud *p2)
{
    double *distance;
    distance = malloc(16 * sizeof(*distance));

    *distance = sqrt((p1->abscisse - p2->abscisse) * (p1->abscisse - p2->abscisse) +(p1->ordonee - p2->ordonee) * (p1->ordonee - p2->ordonee));
    return distance;
}
int main ()
{
    llist ma_liste = NULL;
    noeud *p1 = ma_liste;
     noeud *p2 = ma_liste;

    double * distance = calculer_distance_entre_sommets(p1, p2);
   if (distance == NULL)
    free(distance);
    else
    {
       for(i=0;i<16;i++)
       printf("%lf\n", distance[i]);

return 0;

}

double** calculer_distance (llist client_liste)
{
    noeud *h = client_liste;
    noeud *p1 = client_liste;
    noeud *p2 = client_liste;
    noeud *debut_liste = client_liste;
    int i;
    int j;
    double **distance;

    FILE *fichier = NULL;

    if ((fichier = fopen("D:\\Codes Thèse\\TS2004t3\\test.txt", "r")) == NULL)/*ouverture du fichier en lecture*/
        printf("Error: impossible d'ouvrir fichier donnees.txt\n");

    else//non
    {


        for (i=0;i<5;i++)

            fscanf(fichier, "%i %i %i %i %i %i %i %i",&(h->identifiant),&(h->abscisse),&(h->ordonee),&(h->demande),&(h->temps_service),&(h->borne_inf_tw),&(h->borne_sup_tw),&(h->capacite));
        distance = (double **) malloc (5 * sizeof (double*));
        for (i=0;i<5;i++)
        {

            distance[i]=(double *) malloc (5 * sizeof(double));
        }
        j=0;

        for (p1=debut_liste;p1!=NULL;p1=p1->suivant)

        {
            distance[j][j]= 0.0;
            i=j+1;

            for (p2=p1->suivant;p2!=NULL;p2=p2->suivant)
            {

                distance[i][j]= distance[j][i]= sqrt((p1->abscisse - p2->abscisse) *(p1->abscisse - p2->abscisse) +(p1->ordonee - p2->ordonee) * (p1->ordonee - p2->ordonee));
                i++;
            }
            j++;
        }

        fclose (fichier);


    }
    return distance;
}
int main ()
{
      llist ma_liste = NULL;
      double **matrice_distance = calculer_distance(ma_liste);
}

int main (void) {  
   llist ma_liste = NULL;  
   double *matrice_distance = calculer_distance(ma_liste);  
   /*traitement de la matrice*/  
   
  free(ma_liste), ma_liste = NULL;  
   return 0;  
}  

double **distance = malloc (sizeof (double*));

int i;  
double ***distance=malloc(LIGNE * sizeof (double*));  
for (i=0; i < LIGNE; i++)  
   (*distance)[i]=malloc(COLONNE * sizeof (double)); 

/*utilisation*/ 
(*distance)[i][j]=...; 

**distance=malloc(LIGNE * sizeof (double*));  

 (*distance)[i][j]=..;

double** calculer_distance (llist client_liste) 
{ 
       double **distance; 

      distance = (double **) malloc (5 * sizeof (double*)); 
        for (i=0;i<5;i++) 
        { 

            distance[i]=(double *) malloc (5 * sizeof(double)); 
             return distance; 

        }
   return distance; 
}

 
int main() 
{ 
   double **matrice_distance = calculer_distance(ma_liste); 
}

int rechercher_max_distance(double distance[5][5]) 
{ 
    int j; 
    double max = 0.0; 
    int c; 
    for (j=0;j<5;j++) 
    { 

        if (distance[0][j]>max) 
        { 
            max = distance[0][j]; 

            c = j; 
        } 
    } 
    return c; 
} 
/*initialisation liste circuulaire*/ 
void initialisation (Dlist_solution * liste) 
{ 
    liste->premier = NULL; 
    liste->dernier = NULL; 
    liste->taille = 0; 
} 
/*insertion premier element liste solution*/ 
int ins_liste_solution_vide(Dlist_solution * liste, int val) 
{ 
    solution *nouveau; 
    if ((nouveau = (solution *) malloc (sizeof (solution))) 
            == NULL) 
        return -1; 

    nouveau->no = 0; 

    nouveau->suivant = nouveau; 
    liste->premier = nouveau; 
    liste->dernier = nouveau; 
    liste->taille++; 
    return 0; 
} 


/* insertion dans une liste non-vide */ 
int ins_liste_solution(Dlist_solution* liste, solution *courant, int val) 
{ 
    solution *nouveau; 
    if ((nouveau = (solution *) malloc (sizeof (solution))) 
            == NULL) 
        return -1; 
    nouveau->no = val; 

    if (courant != liste->dernier) 
        return -1; 

    nouveau->suivant = courant->suivant; 
    courant->suivant = nouveau; 
    liste->dernier = nouveau; 
    liste->taille++; 
    return 0; 
} 


/* affichage de la liste */ 
void afficher_solution(Dlist_solution * liste) 
{ 
    solution *courant; 
    courant = liste->premier; 
    int i; 
    for (i=0;i<liste->taille;++i) 
    { 
        printf ("%d\n", courant, courant->no); 
        courant = courant->suivant; 
    } 
} 
int main () 
{ 
    int max;
    llist ma_liste = NULL;
    solution *courant; 
          Dlist_solution *liste;
    if ((liste = (Dlist_solution *) malloc (sizeof (Dlist_solution))) == NULL)
        return -1;
    double **matrice_distance = calculer_distance(ma_liste);max = rechercher_max_distance  (matrice_distance); 
    printf("max est %d\n", max); 
    initialisation (liste); 
    if (liste->taille == 0) 
    { 
        ins_liste_solution_vide(liste,0); 
    } 
    else 
    { 
        ins_liste_solution(liste,liste->dernier,max); 
    } 
     printf ("%d elements:deb=%d, fin=%d\n", 
                                        liste->taille, 
                                        liste->premier->no, 
                                        liste->dernier->no); 
} 

**distance=malloc(LIGNE * sizeof (double*));  

double distance [LIGNE][X]

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

void print_plop(double **plop,int x,int y)
  {
    int i,j;
    for(i=0;i<x;i++)
        for(j=0;j<y;j++)
            printf("plop[%d][%d] = %f\n",i,j,plop[i][j]);
  }

int main(void)
  {
    int i,j;
    double **dist;
/* plop pour simuler des données */
    double plop[4][2]={ {2.3,4.4},{3.5,9.1},
                        {4.6,8.0},{9.4,3.5} };

/* faire de dist un tableau 4*2 */
    dist=malloc(sizeof(double*)*4); /* dist[4][x] tableau de pointeurs */
    for(i=0;i<4;i++)
        dist[i]=malloc(sizeof(double)*2); /* dist[4][2] les pointeurs dirigés vers nouveaux blocs */

/* une copie de plop dans dist */
    for(i=0;i<4;i++)
        for(j=0;j<2;j++)
            dist[i][j]=plop[i][j];
    print_plop(dist,4,2);/* affiche dist en précisant sa taille */

/* liberation de la memoire */
    for(i=0;i<4;i++)
        free(dist[i]);/* libere les pointeurs */
    free(dist); /* libere le tableau */
    return 0;
  }

typedef struct noeud noeud;
struct noeud
{
    
    double abscisse;
    double ordonee;
    
    struct noeud *suivant;
};
typedef noeud* llist;
/*calcul cost entre deux noeuds*/
double cost_deux_noeuds(noeud *p1, noeud *p2)
{

    p1= p1->suivant;
    p2=p1->suivant;

    return sqrt((p1->abscisse - p2->abscisse) *(p1->abscisse - p2->abscisse) +(p1->ordonee - p2->ordonee) * (p1->ordonee - p2->ordonee));
}

    p1= p1->suivant;
    p2=p1->suivant;

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

typedef struct{
    double abscisse;
    double ordonee;
}noeud;

double cost_deux_noeuds(noeud *p1, noeud *p2)
  {
    return sqrt((p1->abscisse - p2->abscisse) * (p1->abscisse - p2->abscisse) + (p1->ordonee - p2->ordonee) * (p1->ordonee - p2->ordonee));
  }

int main(void)
  {
    double resultat;
    noeud *list;
    list=malloc(sizeof(noeud)*4); /* list devient un tableau de type noeud : list[4] , là pour 4 noeuds */
    list[0].abscisse=1.0;/*premier noeud */
    list[0].ordonee=2.0;
    list[1].abscisse=3.0;/*second noeud */
    list[1].ordonee=4.0;
    resultat=cost_deux_noeuds(&list[0],&list[1]);/*on envoit deux noeuds le 0 et 1 de la list*/
    printf("%f\n",resultat);
    free(list); /* libere la list */
    return 0;
  }

typedef struct noeud noeud;
struct noeud
{
    int identifiant;
    double abscisse;
    double ordonee;
    
    struct noeud *suivant;
};
typedef noeud* llist;

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

typedef struct{
    double x,y;
}noeud;

double dist(noeud p1, noeud p2)
  {
    return sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
  }
void print_cout(noeud n,noeud *list,int nblist)
  {
    int i,j;
    for(i=1;i<nblist;i++){
        for(j=0;j<nblist;j++){
            printf("[%.f,%.f]",list[j].x,list[j].y);
            if(i-1==j)printf("[%.f,%.f]",n.x,n.y);
        }
        printf("pos %d : %f\n",i,
                (dist(n,list[i-1])+dist(n,list[i])-dist(list[i-1],list[i]))
                );
    }
  }
int main(void)
  {
    noeud Dlist[2]={{4,3},{6,1}};
    noeud llist[5]={{1,9},{3,5},{4,6},{2,1},{0,9}};
    print_cout(Dlist[0],llist,5);
    return 0;
  }