快速非支配排序

該算法需要計算種群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; }
    }
}