c# 快速排序法并记录数组索引

在遗传算法中，只需要对适应性函数评分进行排序，没必要对所有的个体也参与排序，因为在适应性函数评分排序是可以纪律下最初的索引，排序后的索引随着元素排序而变动，这样就知道那个评分对应那个个体了：

 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;

 namespace ConsoleApplication1arraysort
 {
     class Program
     {
         static void Main(string[] args)
         {
             int[] arr2 = new int[] {,,,,,,,,, };
             List<int> mylist=new List<int> ();
             mylist =arr2.ToList();
             int [] indexArr=new int[arr2.Length];
             for (int i = ; i < indexArr.Length ; i++)
             {
                 indexArr[i] = i;
             }

             QuickSortClass qs = new QuickSortClass();
             qs.QuickSort(mylist, , mylist.Count-,indexArr );

         }

         //http://www.jb51.net/article/86442.htm
         public class QuickSortClass
         {
             public int Division(List<int> list, int left, int right,int[] mindexArr)
             {
                 //首先挑选一个基准元素
                 int baseNum = list[left];
                 int baseIndex = mindexArr[left];
                 while (left < right)
                 {
                     //从数组的右端开始向前找，一直找到比base小的数字为止(包括base同等数)
                     while (left < right && list[right] >= baseNum)
                         right = right - ;
                     //最终找到了比baseNum小的元素，要做的事情就是此元素放到base的位置
                     list[left] = list[right];
                     mindexArr[left] = mindexArr[right];
                     //从数组的左端开始向后找，一直找到比base大的数字为止（包括base同等数）
                     while (left < right && list[left] <= baseNum)
                         left = left + ;
                     //最终找到了比baseNum大的元素，要做的事情就是将此元素放到最后的位置
                     list[right] = list[left];
                     mindexArr[right] = mindexArr[left];
                 }
                 //最后就是把baseNum放到该left的位置
                 list[left] = baseNum;
                 mindexArr[left] = baseIndex;
                 //最终，我们发现left位置的左侧数值部分比left小，left位置右侧数值比left大
                 //至此，我们完成了第一篇排序
                 return left;
             }

             public void QuickSort(List<int> list, int left, int right, int[] mindexArr)
             {
                 //左下标一定小于右下标，否则就超越了
                 if (left < right)
                 {
                     //对数组进行分割，取出下次分割的基准标号
                     int i = Division(list, left, right,mindexArr);

                     //对“基准标号“左侧的一组数值进行递归的切割，以至于将这些数值完整的排序
                     QuickSort(list, left, i - , mindexArr);

                     //对“基准标号“右侧的一组数值进行递归的切割，以至于将这些数值完整的排序
                     QuickSort(list, i + , right, mindexArr);
                 }
             }
         }

     }
 }

评价函数排序

修改，使之输入为数组而不是list：

 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;

 namespace ConsoleApplication1arraysort
 {
     class Program
     {
         static void Main(string[] args)
         {
             double[] arr2 = new double[] { , , , , , , , , ,  };
             int [] indexArr=new int[arr2.Length];
             for (int i = ; i < indexArr.Length ; i++)
             {
                 indexArr[i] = i;
             }

             QuickSortClass qs = new QuickSortClass();
             qs.QuickSort(arr2, , arr2.Length  - , indexArr);
         }

         //http://www.jb51.net/article/86442.htm
         public class QuickSortClass
         {
             public int Division(double[] list, int left, int right,int[] mindexArr)
             {
                 //首先挑选一个基准元素
                 double baseNum = list[left];
                 int baseIndex = mindexArr[left];
                 while (left < right)
                 {
                     //从数组的右端开始向前找，一直找到比base小的数字为止(包括base同等数)
                     while (left < right && list[right] >= baseNum)
                         right = right - ;
                     //最终找到了比baseNum小的元素，要做的事情就是此元素放到base的位置
                     list[left] = list[right];
                     mindexArr[left] = mindexArr[right];
                     //从数组的左端开始向后找，一直找到比base大的数字为止（包括base同等数）
                     while (left < right && list[left] <= baseNum)
                         left = left + ;
                     //最终找到了比baseNum大的元素，要做的事情就是将此元素放到最后的位置
                     list[right] = list[left];
                     mindexArr[right] = mindexArr[left];
                 }
                 //最后就是把baseNum放到该left的位置
                 list[left] = baseNum;
                 mindexArr[left] = baseIndex;
                 //最终，我们发现left位置的左侧数值部分比left小，left位置右侧数值比left大
                 //至此，我们完成了第一篇排序
                 return left;
             }

             public void QuickSort(double[] list, int left, int right, int[] mindexArr)
             {
                 //左下标一定小于右下标，否则就超越了
                 if (left < right)
                 {
                     //对数组进行分割，取出下次分割的基准标号
                     int i = Division(list, left, right,mindexArr);

                     //对“基准标号“左侧的一组数值进行递归的切割，以至于将这些数值完整的排序
                     QuickSort(list, left, i - , mindexArr);

                     //对“基准标号“右侧的一组数值进行递归的切割，以至于将这些数值完整的排序
                     QuickSort(list, i + , right, mindexArr);
                 }
             }
         }

     }
 }

数组快速排序并记录索引

---

list比较是还是得用单个元素，不能一条一条的比较啊：

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

 namespace ConsoleApplication1Listadd
 {
     class Program
     {
         static void Main(string[] args)
         {
             List<List<double>> twoDimeList = new List<List<double>>();
             for (int j = ; j < ; j++)
             {
                 List<double> oneDimeList = new List<double>();
                 for (int i = ; i < ; i++)
                 {
                     oneDimeList.Add(i+j);
                 }
                 twoDimeList.Add(oneDimeList);
             }
             twoDimeList.Add(new List<double> { 1.0,2.0,3.0});
             Console.WriteLine(twoDimeList.Count);//输出行数
             Console.WriteLine(twoDimeList[][]);
             Console.WriteLine(twoDimeList[]==twoDimeList[twoDimeList .Count-]);

         }
     }
 }

list的创建和比较

---