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[] {72,6,57,88,60,42,83,73,48,85 };
            List<int> mylist=new List<int> ();
            mylist =arr2.ToList();
            int [] indexArr=new int[arr2.Length];
            for (int i = 0; i < indexArr.Length ; i++)
            {
                indexArr[i] = i;
            }

            QuickSortClass qs = new QuickSortClass();
            qs.QuickSort(mylist, 0, mylist.Count-1,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 - 1;
                    //最终找到了比baseNum小的元素，要做的事情就是此元素放到base的位置
                    list[left] = list[right];
                    mindexArr[left] = mindexArr[right];
                    //从数组的左端开始向后找，一直找到比base大的数字为止（包括base同等数）
                    while (left < right && list[left] <= baseNum)
                        left = left + 1;
                    //最终找到了比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 - 1, mindexArr);

                    //对“基准标号“右侧的一组数值进行递归的切割，以至于将这些数值完整的排序
                    QuickSort(list, i + 1, 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[] { 72, 6, 57, 88, 60, 42, 83, 73, 48, 85 };           
            int [] indexArr=new int[arr2.Length];
            for (int i = 0; i < indexArr.Length ; i++)
            {
                indexArr[i] = i;
            }

            QuickSortClass qs = new QuickSortClass();
            qs.QuickSort(arr2, 0, arr2.Length  - 1, 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 - 1;
                    //最终找到了比baseNum小的元素，要做的事情就是此元素放到base的位置
                    list[left] = list[right];
                    mindexArr[left] = mindexArr[right];
                    //从数组的左端开始向后找，一直找到比base大的数字为止（包括base同等数）
                    while (left < right && list[left] <= baseNum)
                        left = left + 1;
                    //最终找到了比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 - 1, mindexArr);

                    //对“基准标号“右侧的一组数值进行递归的切割，以至于将这些数值完整的排序
                    QuickSort(list, i + 1, 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 = 0; j < 4; j++)
            {
                List<double> oneDimeList = new List<double>(); 
                for (int i = 0; i < 3; 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[1][1]);
            Console.WriteLine(twoDimeList[1]==twoDimeList[twoDimeList .Count-1]);

        }
    }
}

---