多目标遗传算法 ------ NSGA-II （部分源码解析） 快速排序代码 sort.c

 /* Routines for randomized recursive quick-sort */

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

 # include "global.h"
 # include "rand.h"

 /* Randomized quick sort routine to sort a population based on a particular objective chosen */
 void quicksort_front_obj(population *pop, int objcount, int obj_array[], int obj_array_size)
 {
   q_sort_front_obj (pop, objcount, obj_array, , obj_array_size-);
   return;
 }

 /* Actual implementation of the randomized quick sort used to sort a population based on a particular objective chosen */
 void q_sort_front_obj(population *pop, int objcount, int obj_array[], int left, int right)
 {
     int index;
     int temp;
     int i, j;
     double pivot;
     if (left<right)
     {
         index = rnd (left, right);
         temp = obj_array[right];
         obj_array[right] = obj_array[index];
         obj_array[index] = temp;
         pivot = pop->ind[obj_array[right]].obj[objcount];
         i = left-;
         for (j=left; j<right; j++)
         {
             if (pop->ind[obj_array[j]].obj[objcount] <= pivot)
             {
                 i+=;
                 temp = obj_array[j];
                 obj_array[j] = obj_array[i];
                 obj_array[i] = temp;
             }
         }
         index=i+;
         temp = obj_array[index];
         obj_array[index] = obj_array[right];
         obj_array[right] = temp;
         q_sort_front_obj (pop, objcount, obj_array, left, index-);
         q_sort_front_obj (pop, objcount, obj_array, index+, right);
     }
     return;
 }

按照个体的不同  目标函数 序号（objcount）,  对种群序号数组obj_array按照拥挤距离进行快速排序。

 /* Randomized quick sort routine to sort a population based on crowding distance */
 void quicksort_dist(population *pop, int *dist, int front_size)
 {
   q_sort_dist (pop, dist, , front_size-);
   return;
 }

 /* Actual implementation of the randomized quick sort used to sort a population based on crowding distance */
 void q_sort_dist(population *pop, int *dist, int left, int right)
 {
     int index;
     int temp;
     int i, j;
     double pivot;
     if (left<right)
     {
         index = rnd (left, right);
         temp = dist[right];
         dist[right] = dist[index];
         dist[index] = temp;
         pivot = pop->ind[dist[right]].crowd_dist;
         i = left-;
         for (j=left; j<right; j++)
         {
             if (pop->ind[dist[j]].crowd_dist <= pivot)
             {
                 i+=;
                 temp = dist[j];
                 dist[j] = dist[i];
                 dist[i] = temp;
             }
         }
         index=i+;
         temp = dist[index];
         dist[index] = dist[right];
         dist[right] = temp;
         q_sort_dist (pop, dist, left, index-);
         q_sort_dist (pop, dist, index+, right);
     }
     return;
 }

将带排序的个体索引序号  按照  拥挤距离  排序。（快速排序法）