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

最新推荐文章于 2024-04-01 17:57:41 发布

weixin_33882452

最新推荐文章于 2024-04-01 17:57:41 发布

阅读量481

点赞数

文章标签： c#

原文链接：http://www.cnblogs.com/zhubinglong/p/8351669.html

版权

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

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Diagnostics;
 4 using System.Linq;
 5 using System.Text;
 6 using System.Threading.Tasks;
 7 
 8 namespace ConsoleApplication1arraysort
 9 {
10     class Program
11     {
12         static void Main(string[] args)
13         {
14             int[] arr2 = new int[] {72,6,57,88,60,42,83,73,48,85 };
15             List<int> mylist=new List<int> ();
16             mylist =arr2.ToList();
17             int [] indexArr=new int[arr2.Length];
18             for (int i = 0; i < indexArr.Length ; i++)
19             {
20                 indexArr[i] = i;
21             }
22 
23             QuickSortClass qs = new QuickSortClass();
24             qs.QuickSort(mylist, 0, mylist.Count-1,indexArr );
25          
26 
27         }
28 
29         //http://www.jb51.net/article/86442.htm
30         public class QuickSortClass
31         {
32             public int Division(List<int> list, int left, int right,int[] mindexArr)
33             {
34                 //首先挑选一个基准元素
35                 int baseNum = list[left];
36                 int baseIndex = mindexArr[left];
37                 while (left < right)
38                 {
39                     //从数组的右端开始向前找，一直找到比base小的数字为止(包括base同等数)
40                     while (left < right && list[right] >= baseNum)
41                         right = right - 1;
42                     //最终找到了比baseNum小的元素，要做的事情就是此元素放到base的位置
43                     list[left] = list[right];
44                     mindexArr[left] = mindexArr[right];
45                     //从数组的左端开始向后找，一直找到比base大的数字为止（包括base同等数）
46                     while (left < right && list[left] <= baseNum)
47                         left = left + 1;
48                     //最终找到了比baseNum大的元素，要做的事情就是将此元素放到最后的位置
49                     list[right] = list[left];
50                     mindexArr[right] = mindexArr[left];
51                 }
52                 //最后就是把baseNum放到该left的位置
53                 list[left] = baseNum;
54                 mindexArr[left] = baseIndex;
55                 //最终，我们发现left位置的左侧数值部分比left小，left位置右侧数值比left大
56                 //至此，我们完成了第一篇排序
57                 return left;
58             }
59 
60             public void QuickSort(List<int> list, int left, int right, int[] mindexArr)
61             {
62                 //左下标一定小于右下标，否则就超越了
63                 if (left < right)
64                 {
65                     //对数组进行分割，取出下次分割的基准标号
66                     int i = Division(list, left, right,mindexArr);
67 
68                     //对“基准标号“左侧的一组数值进行递归的切割，以至于将这些数值完整的排序
69                     QuickSort(list, left, i - 1, mindexArr);
70 
71                     //对“基准标号“右侧的一组数值进行递归的切割，以至于将这些数值完整的排序
72                     QuickSort(list, i + 1, right, mindexArr);
73                 }
74             }
75         }
76 
77 
78 
79 
80 
81 
82     }
83 }

评价函数排序

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

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Diagnostics;
 4 using System.Linq;
 5 using System.Text;
 6 using System.Threading.Tasks;
 7 
 8 namespace ConsoleApplication1arraysort
 9 {
10     class Program
11     {
12         static void Main(string[] args)
13         {
14             double[] arr2 = new double[] { 72, 6, 57, 88, 60, 42, 83, 73, 48, 85 };           
15             int [] indexArr=new int[arr2.Length];
16             for (int i = 0; i < indexArr.Length ; i++)
17             {
18                 indexArr[i] = i;
19             }
20 
21             QuickSortClass qs = new QuickSortClass();
22             qs.QuickSort(arr2, 0, arr2.Length  - 1, indexArr);
23         }
24 
25         //http://www.jb51.net/article/86442.htm
26         public class QuickSortClass
27         {
28             public int Division(double[] list, int left, int right,int[] mindexArr)
29             {
30                 //首先挑选一个基准元素
31                 double baseNum = list[left];
32                 int baseIndex = mindexArr[left];
33                 while (left < right)
34                 {
35                     //从数组的右端开始向前找，一直找到比base小的数字为止(包括base同等数)
36                     while (left < right && list[right] >= baseNum)
37                         right = right - 1;
38                     //最终找到了比baseNum小的元素，要做的事情就是此元素放到base的位置
39                     list[left] = list[right];
40                     mindexArr[left] = mindexArr[right];
41                     //从数组的左端开始向后找，一直找到比base大的数字为止（包括base同等数）
42                     while (left < right && list[left] <= baseNum)
43                         left = left + 1;
44                     //最终找到了比baseNum大的元素，要做的事情就是将此元素放到最后的位置
45                     list[right] = list[left];
46                     mindexArr[right] = mindexArr[left];
47                 }
48                 //最后就是把baseNum放到该left的位置
49                 list[left] = baseNum;
50                 mindexArr[left] = baseIndex;
51                 //最终，我们发现left位置的左侧数值部分比left小，left位置右侧数值比left大
52                 //至此，我们完成了第一篇排序
53                 return left;
54             }
55 
56             public void QuickSort(double[] list, int left, int right, int[] mindexArr)
57             {
58                 //左下标一定小于右下标，否则就超越了
59                 if (left < right)
60                 {
61                     //对数组进行分割，取出下次分割的基准标号
62                     int i = Division(list, left, right,mindexArr);
63 
64                     //对“基准标号“左侧的一组数值进行递归的切割，以至于将这些数值完整的排序
65                     QuickSort(list, left, i - 1, mindexArr);
66 
67                     //对“基准标号“右侧的一组数值进行递归的切割，以至于将这些数值完整的排序
68                     QuickSort(list, i + 1, right, mindexArr);
69                 }
70             }
71         }
72 
73 
74 
75 
76 
77 
78     }
79 }

数组快速排序并记录索引

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

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Threading.Tasks;
 6 
 7 namespace ConsoleApplication1Listadd
 8 {
 9     class Program
10     {
11         static void Main(string[] args)
12         {
13             List<List<double>> twoDimeList = new List<List<double>>();            
14             for (int j = 0; j < 4; j++)
15             {
16                 List<double> oneDimeList = new List<double>(); 
17                 for (int i = 0; i < 3; i++)
18                 {                   
19                     oneDimeList.Add(i+j);
20                 }
21                 twoDimeList.Add(oneDimeList);
22             }
23             twoDimeList.Add(new List<double> { 1.0,2.0,3.0});
24             Console.WriteLine(twoDimeList.Count);//输出行数
25             Console.WriteLine(twoDimeList[1][1]);
26             Console.WriteLine(twoDimeList[1]==twoDimeList[twoDimeList .Count-1]);
27 
28         }
29     }
30 }