void fillCrowdingDistance(int count, int frontSize, list *elite)
{
int *distance;
list *temp;
int i, j;
int missing = NP - count;
while(missing<frontSize)
{
assignCrowdingDistanceList(elite->child, frontSize);
distance = (int *)calloc(frontSize,sizeof(int));
temp = elite->child;
for(j=0; j<frontSize; j++)
{
distance[j] = temp->index;
temp = temp->child;
}
quickSortDistance(distance, frontSize);
deleteInd(elite,distance[0]);
frontSize--;
if(missing<frontSize)
{
free(distance);
}
}
for(i=count, j=frontSize-1; i<NP; i++, j--)
{
copyIndividual(distance[j], i);
}
free(distance);
return;
}
/*
* Calcul du sous arbre recouvrant minimal
*
* @param g, graphe
* @return un graphe avec les liaisons du sous arbre recouvrant minimal
*/
struct Graph* minSpanningTree(struct Graph g)
{
int l, c, i=0, nbEdges=0, cityA=-1, cityB=-1;
int isConnexe;
struct Edge edge;
struct Graph* newGraph=NULL;
struct Edge* matrixEdges=NULL;
int* connexeComp=NULL;
float** matrix;
int aux, j, k;
newGraph =(struct Graph*) malloc(sizeof(struct Graph));
newGraph->nbCities = g.nbCities;
connexeComp = malloc(g.nbCities * sizeof(int));
matrixEdges = malloc((g.nbCities*g.nbCities) * sizeof(struct Edge));
newGraph->matrixCities = malloc(g.nbCities * sizeof(struct City));
for(j = 0; j < g.nbCities; j++)
{
newGraph->matrixCities[j] = g.matrixCities[j];
}
matrix = initMatrix(g.nbCities);
for(j = 0; j < g.nbCities; j++)
{
for(k = 0; k < g.nbCities; k++)
{
matrix[j][k] = -1.0;
}
}
for (l = 0; l < g.nbCities-1; l++)
{
for (c = l+1; c < g.nbCities; c++)
{
if(g.matrix[l][c] != -1)
{
edge.cityA = l;
edge.cityB = c;
edge.distance = g.matrix[l][c];
matrixEdges[i] = edge;
i++;
}
}
}
nbEdges = i;
quickSortDistance(matrixEdges, nbEdges);
for (i = 0; i < g.nbCities; i++)
{
connexeComp[i] = i;
}
k = 0;
j = 0;
while (k < (g.nbCities-1) && j<nbEdges)
{
cityA= matrixEdges[j].cityA;
cityB= matrixEdges[j].cityB;
if (connexeComp[cityA] != connexeComp[cityB])
{
k++;
matrix[cityA][cityB] = getDistance(g, cityA, cityB);
aux = connexeComp[cityB];
for (i = 0; i < g.nbCities; i++)
{
if (connexeComp[i] == aux)
{
connexeComp[i] = connexeComp[cityA];
}
}
}
j++;
}
i = 0;
isConnexe = 1;
while (i < g.nbCities-1 && isConnexe)
{
if (connexeComp[i] != connexeComp[i+1])
{
isConnexe = 0;
}
i++;
}
newGraph->matrix = matrix;
if (isConnexe == 0)
{
free(connexeComp);
free(matrixEdges);
deleteGraph(*newGraph);
free(newGraph);
printf("The graph is not connected : there is no minimum spanning tree between these cities.\n");
return NULL;
}
free(connexeComp);
free(matrixEdges);
return newGraph;
}
