快速非支配排序

该算法需要计算种群P中每个个体i的两个参数ni（种群中支配个体i的个体数目）和si（种群中被个体i支配的个体集合）。

1、找出种群中所有ni=0的个体，保存在集合F1中（也就是第一层）。

2、对F1中的每个个体i，其所支配的个体集合为si，遍历si中每个个体L，nL=nL-1,若nL=0，将L保存在集合H中（第二层）。

3、以H为当前集合，重复2，直到整个种群被分层

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            var db = new List<Individual>
                {
                    new Individual(new List<double>() {1, 8}),
                    new Individual(new List<double>() {2, 6}),
                    new Individual(new List<double>() {3, 4}),
                    new Individual(new List<double>() {2, 5}),
                    new Individual(new List<double>() {4, 9})
                };
            var result=NondominantSort.First_Nondominant_Sort(db);
        }
    }
    public class NondominantSort
    {
        public static List<Tier> First_Nondominant_Sort(List<Individual> individuals)
        {
            var result = new List<Tier>();
            foreach (var p in individuals)//初始化所有个体的各个属性值
            {
                foreach (var q in individuals)
                {
                    var paretoRelation = Pareto(p, q);
                    if (paretoRelation == 1)
                        p.MyDominant.Add(q);
                    else if (paretoRelation == 2)
                    {
                        p.DominantNumber += 1;
                    }
                }
            }
            var tireF1 = GetTire(individuals);//获取第一层

            var newTier = new Tier();
            newTier.Individuals.AddRange(tireF1);
            
            result.Add(newTier);
            var tire = GetH(tireF1);
            while (tire.Count > 0)
            {
                var newTier1 = new Tier();
                newTier1.Individuals.AddRange(tire);
                
                result.Add(newTier1);
                tire = GetH(tire);
                //tire.Clear();
            }
            return result;
        }
        /// <summary>
        /// 根据上一层 获取下一层H
        /// </summary>
        /// <returns></returns>
        public static List<Individual> GetH(List<Individual> tire)
        {
            var result = new List<Individual>();
            foreach (var individual in tire)
            {
                foreach (var individual1 in individual.MyDominant)
                {
                    individual1.DominantNumber -= 1;
                    if (individual1.DominantNumber == 0)
                        result.Add(individual1);
                }
            }

            return result;
        }
        /// <summary>
        /// 获取一层
        /// </summary>
        /// <param name="individuals"></param>
        /// <returns></returns>
        public static List<Individual> GetTire(List<Individual> individuals)
        {
            return individuals.Where(individual => individual.DominantNumber == 0).ToList();
        }
        /// <summary>
        /// individual1支配individual2返回1，individual2支配individual1返回2，互不支配返回3，返回4两个体相同（以最小值为例）
        /// </summary>
        /// <param name="individual1">个体1</param>
        /// <param name="individual2">个体2</param>
        /// <returns>支配关系</returns>
        public static int Pareto(Individual individual1, Individual individual2)
        {
            var number1 = individual1.Numbers;
            var number2 = individual2.Numbers;
            var count = number1.Count;
            var results = new int[count];
            for (int i = 0; i < count; i++)
            {
                if (number1[i] == number2[i])
                {
                    results[i] = 0;
                }
                else if (number1[i] < number2[i])
                    results[i] = 1;
                else
                {
                    results[i] = 2;
                }
            }
            if (results.Contains(1) && !results.Contains(2))
            {
                return 1;//1支配2
            }
            else if (!results.Contains(1) && results.Contains(2))
                return 2;//2支配1
            else if (results.Contains(1) && results.Contains(2))
            {
                return 0;//互不支配
                //throw new Exception("两个体为同一个个体");
            }
            else
            {
                //完全相同的个体
                return 4;
            }
        }
    }
    /// <summary>
    /// 个体
    /// </summary>
    public class Individual
    {
        public Individual(IEnumerable<double> db)
        {
            this.Numbers = new List<double>();
            this.Numbers.AddRange(db);
            this.MyDominant = new List<Individual>();
            this.DominantNumber = 0;
        }
        /// <summary>
        /// 有DominantNumber个个体支配该个体
        /// </summary>
        public int DominantNumber { get; set; }
        /// <summary>
        /// 该个体支配其他个体的集合
        /// </summary>
        public List<Individual> MyDominant { get; set; }
        /// <summary>
        /// 该个体各个维度数值
        /// </summary>
        public List<double> Numbers { get; set; }
        public void Clean()
        {
            this.Numbers.Clear();
            this.DominantNumber = 0;
            this.MyDominant.Clear();
        }
    }
    /// <summary>
    /// 非支配中的一层
    /// </summary>
    public class Tier
    {
        public Tier()
        {
            this.Individuals = new List<Individual>();
        }
        public List<Individual> Individuals { get; set; }
    }
}