泛型排序构建可反转排序的泛型字典类(9完)--完善

目标
本章学习目标：
了解集合和集合接口的用途
了解泛型列表类型、集合、字典类型和链表类型 了解专用字集合类
了解集合基类和字典基础类型
第6章 集合和泛型
集合和集合接口 使用主要集合类型 使用泛型集合 使用专用集合 使用集合基类 小结 实验 习题
集合和集合接口
6.1 集合和集合接口
集合
集合是指通过高度结构化的方式存储任意对象的类。
专用Dictionary类
使用专用集合（续）
6.4 使用专用集合
续表:
专用 Named Collection 类 Named Collection 类提供了集合的抽象基类，该集合包括相 关联的字符串键和对象值，可以通过键或者索引访问这些对 象值。 NameValueCollection 允许将多个字符串值与单个字符串键相 关联。可以通过派生 NameObjectCollectionBase 类创建具有各自 专用行为的键/值集合。 位结构提供一个用于存储 Boolean 值和小整数的简单结构。 BitVector32 将 Boolean 值存储在 32 位结构中。BitVector32.Section 使你能将小整数存储在 BitVector32 类中。
2.
使用泛型 Queue 类以实现 FIFO 。
泛型 Stack 类的功能和非泛型 Stack 类相似，只不过泛型 Stack 包含特定数据类型的元素。 泛型 Queue 类与非泛型 Queue 类相同，只不过泛型 Queue 包含 特定数据类型的元素。
代码示例C＃
代码示例VB
第6章 集合和泛型
集合和集合接口 使用主要集合类型 使用泛型集合 使用专用集合 使用集合基类 小结 实验 习题
（1）Sortedlist类

数组反转方法在编程中，数组是一种重要的数据结构，它允许我们存储和处理大量相似类型的数据。

数组中的元素按照特定的顺序存储，并且可以通过索引访问。

有时候我们需要对数组中的元素进行反转操作，即将原来的顺序颠倒过来。

本文将介绍一些常见的数组反转方法，帮助您在实际编程中灵活运用。

一、内置方法实现数组反转在许多编程语言中，提供了内置的方法来实现数组的反转操作。

下面是一些常见语言的例子：1. Python语言：在Python中，可以使用[::-1]的方式对数组进行反转。

例如，有一个名为arr的数组，可以通过arr[::-1]来实现数组元素的反转。

2. JavaScript语言：在JavaScript中，可以使用Array对象的reverse()方法对数组进行反转。

例如，有一个名为arr的数组，可以通过arr.reverse()来实现数组元素的反转。

这些内置方法是实现数组反转的最简单、快速的方法之一。

然而，有时候我们可能需要自己编写算法来完成数组反转，下面将介绍其他实现方法。

二、循环交换法实现数组反转另一种常见的数组反转方法是循环交换法。

该方法使用两个指针分别指向数组的首尾元素，然后交换它们的值，并依次向中间移动。

具体步骤如下：1. 初始化两个指针，一个指向数组的首元素，记为left，另一个指向数组的尾元素，记为right。

2. 当left小于right时，交换left和right位置上的元素，并将left指针右移一位，将right 指针左移一位。

3. 重复步骤2，直到left大于或等于right为止。

下面是一个使用循环交换法实现数组反转的示例代码（以Java语言为例）：```javavoid reverseArray(int[] arr) {int left = 0;int right = arr.length - 1;while (left < right) {int temp = arr[left];arr[left] = arr[right];arr[right] = temp;left++;right--;三、递归实现数组反转除了循环交换法，我们还可以使用递归的方式实现数组反转。

数组反转方法数组反转是指将数组中的元素按照相反的顺序重新排列。

以下是关于数组反转的十条方法：1. 逐位交换法：从数组的两端开始，依次交换对称位置上的元素，直到数组中间位置。

对于数组 [1, 2, 3, 4, 5]，首先交换第一个元素和最后一个元素，然后交换第二个元素和倒数第二个元素，以此类推。

最终数组变为 [5, 4, 3, 2, 1]。

2. 新建数组法：创建一个新的空数组，从原始数组的末尾开始，依次将元素添加到新数组中。

对于数组 [1, 2, 3, 4, 5]，创建一个新数组，然后将原始数组的最后一个元素 5 添加到新数组中，接着将倒数第二个元素 4 添加到新数组中，以此类推，最终得到 [5, 4, 3, 2, 1]。

3. 双指针法：使用两个指针分别指向数组的首尾位置，然后逐步移动指针并交换对应元素的值，直到两个指针相遇。

对于数组 [1, 2, 3, 4, 5]，初始化指针 p1 指向首位元素 1，指针 p2 指向末位元素 5。

然后依次交换 p1 和 p2 指向的元素，并将两个指针向中间移动一位，直到两个指针相遇。

最终得到 [5, 4, 3, 2, 1]。

4. 遍历拷贝法：遍历原数组，将每个元素从最后一位开始依次添加到新的数组中。

对于数组 [1, 2, 3, 4, 5]，创建一个新数组，并从原数组的最后一位开始，依次将元素添加到新数组中。

最终得到 [5, 4, 3, 2, 1]。

5. 使用Collections.reverse()方法：利用Java的Collections工具类中的reverse()方法实现数组反转。

使用Arrays.asList()方法将数组转换为List集合，然后使用Collections.reverse()方法将List集合中的元素反转，最后再将反转后的List转换为数组。

6. 使用List的reverse()方法：将数组转换为List集合，然后使用List的reverse()方法反转元素顺序，最后再将反转后的List转换为数组。

python dict 的sort函数Python是一种功能强大的编程语言，提供了许多内置的数据结构和函数来帮助开发者处理和操作数据。

其中，字典（dict）是一种非常常用的数据结构，用于存储键值对。

在Python中，字典是无序的，这意味着字典中的元素没有固定的顺序。

然而，有时我们需要对字典进行排序，以便更好地处理和展示数据。

本文将介绍如何使用Python的sort函数对字典进行排序。

让我们先了解一下字典的基本概念。

字典是一种可变容器模型，可以存储任意数量的数据。

字典由键和对应的值组成，每个键值对之间用冒号(:)分隔，键值对之间用逗号(,)分隔，并且整个字典包含在花括号({})中。

在Python中，字典的排序是基于键（key）的排序。

sort函数可以通过指定键来对字典进行排序。

sort函数是Python内置的函数，可以用于对可迭代对象进行排序。

它的基本语法如下所示：sorted(iterable, key=key, reverse=reverse)其中，iterable是要排序的可迭代对象，key是一个用于指定排序的函数，reverse是一个布尔值，用于指定是否按降序排序。

接下来，让我们来看一个具体的示例。

假设我们有一个字典，存储了一些学生的姓名和对应的分数，我们希望按照分数从高到低的顺序对学生进行排序。

我们可以使用sort函数来完成这个任务，代码如下所示：```pythonstudents = {'Alice': 85, 'Bob': 73, 'Charlie': 92, 'David': 88}sorted_students = sorted(students.items(), key=lambda x: x[1], reverse=True)```在上面的代码中，我们首先定义了一个字典students，它存储了学生的姓名和对应的分数。

java中的按字典排序方法在Java中，可以使用不同的方法对字符串进行字典排序。

下面将介绍几种用于字典排序的常见方法。

1. 字符串数组排序如果有一个字符串数组需要进行字典排序，可以使用Arrays类中的sort()方法进行排序。

这个方法使用的是快速排序算法，可以对字符串数组按字典顺序进行排序。

例如：javaimport java.util.Arrays;public class DictionarySort {public static void main(String[] args) {String[] words = {"java", "c++", "python", "ruby"};字典排序Arrays.sort(words);输出排序结果for (String word : words) {System.out.println(word);}}}输出结果为：c++javapythonruby2. 字符串列表排序如果有一个字符串列表需要进行字典排序，也可以使用Collections类中的sort()方法进行排序。

这个方法使用的是归并排序算法，可以对字符串列表按字典顺序进行排序。

例如：javaimport java.util.ArrayList;import java.util.Collections;public class DictionarySort {public static void main(String[] args) {ArrayList<String> words = new ArrayList<>();words.add("java");words.add("c++");words.add("python");words.add("ruby");字典排序Collections.sort(words);输出排序结果for (String word : words) {System.out.println(word);}}}输出结果为：c++javapythonruby3. 自定义比较器排序如果想要根据自定义规则进行字典排序，可以实现Comparator接口并重写compare()方法。

reverse函数用法
reverse()函数是用来反转或倒序排列一个可迭代对象（例如列表、元组或字符串）中的元素。

准确回答reverse()函数的用法如下：
1.对于列表，reverse()函数将会反转列表中的元素的顺序，即将
列表的最后一个元素放在第一个位置，倒数第二个元素放在第二个位置，依此类推。

2.对于字符串，reverse()函数将会反转字符串中的字符的顺序，
即将最右侧的字符放在最左侧，倒数第二个字符放在第二个位置，依
此类推。

3.对于元组，reverse()函数将会创建一个新的元组，其中元素的
顺序为原始元组的倒序。

值得注意的是，reverse()函数是原地修改可迭代对象（例如列表），而不返回一个新的对象。

拓展：
除了使用reverse()函数之外，我们还可以使用切片（slice）的方法来实现反转一个可迭代对象的元素。

例如，对于列表，可以使用list[::-1]来实现反转，对于字符串，可以使用string[::-1]来实现反转，对于元组，可以使用tuple[::-1]来实现反转。

这种方法会返回一个新的对象，而不是原地修改。

java反转字符串的方法反转字符串是Java语言中一个常见的操作。

它可以将一个字符串反转过来，也就是将字符串中的每一个字符顺序倒过来排列。

在Java中，我们可以使用多种方法来实现字符串的反转。

下面将介绍几种常用的反转字符串的方法。

方法一：StringBuilder或StringBuffer类的reverse()方法StringBuilder或StringBuffer类的reverse()方法是最简单的反转字符串方法之一。

StringBuilder或StringBuffer类都是可变、可修改字符串的类。

它们都有一个reverse()方法，该方法可以将字符串中的字符顺序反转过来。

示例代码如下：```public String reverseString(String str) {StringBuilder sb = new StringBuilder(str);return sb.reverse().toString();}```在这个方法中，我们首先创建了一个StringBuilder对象，然后将原始字符串作为参数传递给StringBuilder的构造函数。

接着，我们调用了StringBuilder的reverse()方法，将字符串中的字符顺序反转。

最后，我们使用toString()方法将StringBuilder对象转换为字符串，以便使用该方法的调用者得到反转后的字符串。

方法二：使用字符数组在Java中，字符串是不可变的，所以我们不能直接修改字符串中的字符。

但是，我们可以将字符串转换为字符数组，然后对字符数组进行反转。

最后，我们将反转后的字符数组转换回字符串即可。

以下是实现该方法的代码示例：```public String reverseString(String str) {// 将字符串转换为字符数组char[] charArray = str.toCharArray();// 定义两个指针，分别指向数组的首尾int i = 0, j = charArray.length - 1;// 循环交换数组的元素while (i < j) {char temp = charArray[i];charArray[i] = charArray[j];charArray[j] = temp;i++;j--;}// 将字符数组转换为字符串return new String(charArray);}```在这个方法中，我们首先将原始字符串转换为字符数组，然后定义两个指针，i和j。

AICE人工智能等级考试二级考前冲刺1.下列哪项事件标志着人工智能的诞生?（） [单选题] *A:美国人莫克利和艾克特发明了世界第一台计算机B:AlphaGo击败围棋世界冠军C:达特茅斯会议(正确答案)D:自动驾驶车的发明与使用答案解析：达特茅斯会议标志着人工智能的诞生。

该会议于1956年在美国举行，是人工智能领域的首次国际会议，汇聚了当时世界各地最领先的计算机科学家和心理学家，成为人工智能的象征。

选择C选项。

2.执行下方程序，打印的结果是?（）a = 15while a>=10:print(a,end=' ')a-=1 [单选题] *A:15 14 13 12 11 10(正确答案)B:15 14 13 12 11C:10 11 12 13 14 15D:11 12 13 14 15答案解析：执行while循环：当a = 15时，满足条件a>=10，会输出15，a -= 1 相当于 a = a - 1 , a的值变为14；当a = 14时，满足条件a>=10，会输出14，a 的值减1 ，变为13；当a = 13时，满足条件a>=10，会输出13，a 的值减1 ，变为12；当a = 12时，满足条件a>=10，会输出12，a 的值减1 ，变为11；当a = 11时，满足条件a>=10，会输出11，a 的值减1 ，变为10；当a = 10时，满足条件a>=10，会输出10，a 的值减1 ，变为9；当a = 9时，不满足条件a>=10，循环结束；关键字end=' '可以用于将结果输出到同一行中间用一个空格分开，所以输出结果是15 14 13 12 11 10，选择A选项。

3.执行下方程序，选项中描述错误的是?（）while True:print('你的电脑已被入侵') [单选题] *A:这是一个无限循环的程序B:这是一个有限循环的程序，只会打印一次‘你的电脑已被入侵’(正确答案)C:如果不强制停止，这个程序会一直运行下去D:如果把True换成False，那么输出区不会有任何打印结果答案解析：while后的条件为True，即程序会一直执行，所以这是一个无限循环的程序，A选项正确；程序会一直执行print('你的电脑已被入侵')，所以会一直输出'你的电脑已被入侵'，是无限循环的程序。

排序和反转是列表操作中常用的两个方法，在Python编程中，列表是一种非常常用的数据结构，排序和反转列表元素能够帮助我们更方便地对数据进行处理和分析。

本文将详细介绍sort()和reverse()在列表中的用法，以及它们的具体实现方法和注意事项。

一、sort()方法的用法1.1 sort()方法的基本语法sort()方法是Python中列表对象的一个内置方法，用于对列表中的元素进行排序。

它的基本语法格式如下：```pythonlist.sort(reverse=False)```1.2 sort()方法的参数sort()方法接受一个参数reverse，reverse的值默认为False，表示按照升序进行排序。

如果reverse的值为True，则表示按照降序进行排序。

1.3 sort()方法的示例下面是一个简单的示例演示sort()方法的使用：```pythonnumbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]numbers.sort()print(numbers)```运行结果为：[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]1.4 sort()方法的注意事项在使用sort()方法时，需要注意以下几点：（1）sort()方法会改变原列表的顺序，而不是返回一个新的已排序列表。

（2）sort()方法只能对相同类型的元素进行排序，如果列表中包含不同类型的元素，将会导致错误。

二、reverse()方法的用法2.1 reverse()方法的基本语法reverse()方法是Python中列表对象的另一个内置方法，用于对列表中的元素进行反转。

它的基本语法格式如下：```pythonlist.reverse()```2.2 reverse()方法的示例下面是一个简单的示例演示reverse()方法的使用：```pythonnumbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]numbers.reverse()print(numbers)```运行结果为：[5, 3, 5, 6, 2, 9, 5, 1, 4, 1, 3]2.3 reverse()方法的注意事项在使用reverse()方法时，需要注意以下几点：（1）reverse()方法同样会改变原列表的顺序，而不是返回一个新的已反转列表。

C#中Dictionary的⽤法及⽤途实例⼀、Dictionary<string, string>是⼀个泛型他本⾝有集合的功能有时候可以把它看成数组他的结构是这样的：Dictionary<[key], [value]>他的特点是存⼊对象是需要与[key]值⼀⼀对应的存⼊该泛型通过某⼀个⼀定的[key]去找到对应的值举个例⼦：//实例化对象Dictionary<int, string> dic = new Dictionary<int, string>();//对象打点添加dic.Add(1, "one");dic.Add(2, "two");dic.Add(3, "one");//提取元素的⽅法string a = dic[1];string b = dic[2];string c = dic[3];//1、2、3是键，分别对应“one”“two”“one”//上⾯代码中分别把值赋给了a,b,c//注意,键相当于找到对应值的唯⼀标识，所以不能重复//但是值可以重复--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------⼆、c# 对dictionary类进⾏排序⽤什么接⼝实现如果使⽤.Net Framework 3.5的话，事情就很简单了。

呵呵。

如果不是的话，还是⾃⼰写排序吧。

View Code1using System;23using System.Collections.Generic;45using System.Text;67using System.Linq;89namespace DictionarySorting1011 {1213class Program1415 {1617static void Main(string[] args)1819 {2021 Dictionary<int, string> dic = new Dictionary<int, string>();23 dic.Add(1, "HaHa");2425 dic.Add(5, "HoHo");2627 dic.Add(3, "HeHe");2829 dic.Add(2, "HiHi");3031 dic.Add(4, "HuHu");3233 var result = from pair in dic orderby pair.Key select pair;3435foreach (KeyValuePair<int, string> pair in result)3637 {3839 Console.WriteLine("Key:{0}, Value:{1}", pair.Key, pair.Value);4041 }4243 Console.ReadKey();4445 }4647 }4849 }5051【执⾏结果】5253 Key:1, Value:HaHa5455 Key:2, Value:HiHi5657 Key:3, Value:HeHe5859 Key:4, Value:HuHu6061 Key:5, Value:HoHo================================================================================三、Dictionary的基本⽤法。

python中reverse的用法Python中的reverse()方法是一种排序函数，可以反转列表、元组、字符串中的元素。

它仅可以使用于可迭代的序列，以及输入一个列表生成一个新的列表。

reverse()函数会逆转其参数，即原列表里面的元素按照倒序排序。

它可以用来对表中的元素进行排序，以获得更好的调试结果。

它也可以用于其他应用程序来反转字符串或顺序列表，以及检查是否异或等等。

reverse()函数使用简单，它只需要一个列表作为参数，可以进行倒序排序。

例如：list = [1,2,3,4,5]list.reverse()print(Reversed List: list)输出结果为：Reversed List: [5,4,3,2,1]使用reverse函数可以更快速地将列表或元组中的元素反转排序。

它返回一个新的列表，而不影响原始列表。

例如：list = [1,2,3,4,5]sorted_list = list[::-1]print(Reversed List: sorted_list)输出结果为：Reversed List: [5,4,3,2,1]另外，reverse()方法还可以用于对字符串进行反转排序。

例如： a = abcdeprint(Reversed String: a[::-1])输出结果为：Reversed String: edcba反转字符串使用reverse()函数是一个高效的方式，可以避免使用循环或创建新的列表来反转字符串。

此外，如果列表中的元素是数字或字符串，那么reverse()函数只会对元素进行反转，而不会对元素进行排序。

它也可以用于检查两个列表是否相等。

如果两个列表中的元素相同，可以使用reverse()函数将它们比较。

如果列表在反转后仍然相等，则表明它们包含相同的元素。

最后，另一个有用的运用是使用reverse()函数来检查列表中的元素是否异或。

如果列表中的所有元素异或，则将其反转可以获得相同的结果，因此可以利用这个特性来通过比较反转的列表来检查是否异或。

C#字典Dictionary排序（顺序、倒序）⼀、创建字典Dictionary 对象 假如 Dictionary 中保存的是⼀个⽹站页⾯流量，key 是⽹页名称，值value对应的是⽹页被访问的次数，由于⽹页的访问次要不断的统计，所以不能⽤ int 作为 key，只能⽤⽹页名称，创建 Dictionary 对象及添加数据代码如下：Dictionary<string, int> dic = new Dictionary<string, int>(); dic.Add("index.html", 50); dic.Add("product.html", 13); dic.Add("aboutus.html", 4); dic.Add("online.aspx", 22); dic.Add("news.aspx", 18);⼆、.net 2.0 版本 Dictionary排序List<KeyValuePair<string, int>> lst = new List<KeyValuePair<string, int>>(dic); //倒叙排列：只需要把变量s2 和 s1 互换就⾏了例： return pareTo(s2.Value); //进⾏排序⽬前是顺序 lst.Sort(delegate(KeyValuePair<string, int> s1, KeyValuePair<string, int> s2) { return pareTo(s1.Value); });List<KeyValuePair<string,int>> list=new List<KeyValuePair<string, int>>(dic);list.Sort((s1, s2) => { return pareTo(s2.Value); });　三、.net 3.5 以上版本 Dictionary排序（即 linq dictionary 排序） 使⽤linq排序var dicSort = from objDic in dic orderby objDic.Value descending select objDic;var dicNew = dic.OrderBy(s1=>s1.Value);输出要⽤这个输出：foreach(KeyValuePair<string, int> kvp in dicSort){ Response.Write(kvp.Key + "：" + kvp.Value + "<br />");}。

返回list的泛型方法
在很多编程语言中，可以使用泛型方法来返回一个泛型类型的列表（List）。下面是一个
示例，展示了如何使用Java编程语言中的泛型方法返回一个List：
```java import java.util.ArrayList; import java.util.List;
public class GenericMethodExample { public static <T> List<T> getList(T[] array) { List<T> list = new ArrayList<>(); for (T element : array) { list.add(element); } return list; }
Integer[] intArray = {1, 2, 3, 4, 5}; List<Integer> intList = getList(intArray); System.out.println(intList); } } ```
返回list的泛Байду номын сангаас方法
在上面的示例中，`getList`方法是一个泛型方法，它接受一个泛型数组作为参数，并返回 一个泛型类型的List。在方法内部，我们使用了一个ArrayList来创建一个空的List对象，然后 遍历传入的数组，将每个元素添加到List中。最后，返回这个List。
在`main`方法中，我们分别传入了一个String类型的数组和一个Integer类型的数组，调 用`getList`方法并将返回的List打印出来。由于`getList`方法是泛型方法，所以它可以根据传 入的实际类型来确定返回的List的类型。

详测 Generics Collections TQueueuses Generics.Collections;procedure TForm1.Button1Click(Sender: TObject);varQueue: TQueue<string>;s,str: string;List: TList<string>;beginQueue := TQueue<string>.Create();{入列}Queue.Enqueue('AAA');Queue.Enqueue('BBB');Queue.Enqueue('CCC');Queue.Enqueue('DDD');{查看}str := '';for s in Queue do str := str + s + ' ';ShowMessage(str); {AAA BBB CCC DDD}{出列, 并查看出列元素}ShowMessage(Queue.Dequeue); {AAA}str := '';for s in Queue do str := str + s + ' ';ShowMessage(str); {BBB CCC DDD}{查看下一个将要出列的是...}ShowMessage(Queue.Peek); {BBB}Queue.Free;//从 TList<T> 建立 TQueue<T>List := TList<string>.Create();List.AddRange(['AA', 'BB', 'CC']);Queue := TQueue<string>.Create(List);str := '';for s in Queue do str := str + s + ' ';ShowMessage(str); {AA BB CC }ShowMessage(IntToStr(Queue.Count)); {3}Queue.Clear;ShowMessage(IntToStr(Queue.Count)); {0}//Queue.TrimExcess; { TrimExcess 方法在 Queue 好像没有存在的意义} List.Free;Queue.Free;end;详测 Generics Collections TQueue (3): OnNotify、Extract//uses Generics.Collections;{准备给 TQueue.OnNotify 调用的事件过程}procedure TForm1.MyQueueNotify(Sender: TObject; const Item: Integer; Action: TCollectionNotification);begincase Action ofcnAdded : ShowMessageFmt('Add: %d', [Item]);cnRemoved : ShowMessageFmt('Remove: %d', [Item]);cnExtracted : ShowMessageFmt('Extract: %d', [Item]);end;end;procedure TForm1.Button1Click(Sender: TObject);varQueue: TQueue<Integer>;beginQueue := TQueue<Integer>.Create();Queue.OnNotify := MyQueueNotify;Queue.Enqueue(11); {Add: 11}Queue.Enqueue(22); {Add: 22}Queue.Enqueue(33); {Add: 33}Queue.Dequeue; {Remove: 11}// Extract 和 Dequeue 功能一致, 区别只是在驱动 OnNotify 事件时传递的参数有区别, 没多大意义Queue.Extract; {Extract: 22}//Queue.OnNotify := nil;Queue.Free; {Remove: 33}end;详测 Generics Collections TStack(1): Push、Pop、Peek - 其他功能同 TQueueuses Generics.Collections;procedure TForm1.Button1Click(Sender: TObject);varStack: TStack<string>;s,str: string;beginStack := TStack<string>.Create();{压栈}Stack.Push('AAA');Stack.Push('BBB');Stack.Push('CCC');str := '';for s in Stack do str := str + s + ' ';ShowMessage(str); {AAA BBB CCC }{出栈: 后进的先出}Stack.Pop;str := '';for s in Stack do str := str + s + ' ';ShowMessage(str); {AAA BBB }{下一个将要出栈的...}ShowMessage(Stack.Peek); {BBB}Stack.Free;end;详测 Generics Collections TDictionary(1):uses Generics.Collections;procedure TForm1.Button1Click(Sender: TObject);varDictionary: TDictionary<string,Integer>;K: string;V: Integer;str: string;b: Boolean;T: Integer;ds: TDictionary<string,Integer>.TPairEnumerator;ks: TDictionary<string,Integer>.TKeyEnumerator;vs: TDictionary<string,Integer>.TValueEnumerator;beginDictionary := TDictionary<string,Integer>.Create();{添加}Dictionary.Add('n1', 111);Dictionary.Add('n2', 222);Dictionary.Add('n3', 333);{访问}ShowMessage(IntToStr(Dictionary['n2'])); {222}ShowMessage(IntToStr(Dictionary.Items['n2'])); {222}{遍历 Keys}str := '';for K in Dictionary.Keys do str := str + K + ' ';ShowMessage(str); {n2 n3 n1 }//顺序乱了?{遍历 Values}str := '';for V in Dictionary.Values do str := str + IntToStr(V) + ' ';ShowMessage(str); {222 333 111 }{通过 Keys 遍历 Values}str := '';for K in Dictionary.Keys do str := str + IntToStr(Dictionary[K]) + ' ';ShowMessage(str); {222 333 111 }{删除}Dictionary.Remove('n1');str := '';for K in Dictionary.Keys do str := str + IntToStr(Dictionary[K]) + ' ';ShowMessage(str); {222 333 }{取数量、清空}ShowMessage(IntToStr(Dictionary.Count)); {2}Dictionary.Clear;ShowMessage(IntToStr(Dictionary.Count)); {0}{判断指定的 Key 是否存在}b := Dictionary.ContainsKey('n1');ShowMessage(BoolToStr(b, True)); {True}b := Dictionary.ContainsKey('n4');ShowMessage(BoolToStr(b, True)); {False}{判断指定的 Value 是否存在}b := Dictionary.ContainsValue(111);ShowMessage(BoolToStr(b, True)); {True}b := Dictionary.ContainsValue(999);ShowMessage(BoolToStr(b, True)); {False}{使用 AddOrSetValue 时, 如果 Key 存在则替换值; 此时如果用 Add 将发生异常}Dictionary.AddOrSetValue('n1', 123);ShowMessage(IntToStr(Dictionary['n1'])); {123}{使用 AddOrSetValue 时, 如果 Key 不存在则同 Add}Dictionary.AddOrSetValue('n4', 444);ShowMessage(IntToStr(Dictionary['n4'])); {444}{尝试取值}if Dictionary.TryGetValue('n2', T) thenShowMessage(IntToStr(T)); {222}ds := Dictionary.GetEnumerator;while ds.MoveNext do ShowMessageFmt('%s:%d', [ds.Current.Key, ds.Current.Value]);{n2:222 n3:333 n1:111}ks := Dictionary.Keys.GetEnumerator;while ks.MoveNext do ShowMessageFmt('%s', [ks.Current]);{n2 n3 n1}vs := Dictionary.Values.GetEnumerator;while vs.MoveNext do ShowMessageFmt('%d', [vs.Current]);{222 333 111}{ ExtractPair 应是提取元素, 但它的返回值有些问题; 该函数源码有待修改 }Dictionary.ExtractPair('n1');ShowMessage(IntToStr(Dictionary.Count)); {2}Dictionary.Free;end;详测 Generics Collections TDictionary(4): OnKeyNotify、OnValueNotifyinterfaceusesGenerics.Collections;implementationprocedure TForm1.KeyNotify(Sender: TObject; const Item: string;Action: TCollectionNotification);begincase Action ofcnAdded : ShowMessageFmt('Key_Add: %s', [Item]);cnRemoved : ShowMessageFmt('Key_Remove: %s', [Item]);cnExtracted : ShowMessageFmt('Key_Extract: %s', [Item]);end;end;procedure TForm1.ValueNotify(Sender: TObject; const Item: Integer;Action: TCollectionNotification);begincase Action ofcnAdded : ShowMessageFmt('Value_Add: %d', [Item]);cnRemoved : ShowMessageFmt('Value_Remove: %d', [Item]);cnExtracted : ShowMessageFmt('Value_Extract: %d', [Item]);end;end;procedure TForm1.Button1Click(Sender: TObject);varDictionary: TDictionary<string,Integer>;beginDictionary := TDictionary<string,Integer>.Create();Dictionary.OnKeyNotify := KeyNotify;Dictionary.OnValueNotify := ValueNotify;Dictionary.Add('n1', 111); {Key_Add: n1; Value_Add: 111}Dictionary.Add('n2', 222); {Key_Add: n2; Value_Add: 222}Dictionary.AddOrSetValue('n1', 123); {Value_Remove: 111; Value_Add: 123}Dictionary.Remove('n1'); {Key_Remove: n1; Value_Remove: 111} Dictionary.ExtractPair('n2'); {Key_Extract: n2; Value_Extract: 222} Dictionary.OnKeyNotify := nil;Dictionary.OnValueNotify := nil;Dictionary.Free;end;详测 Generics Collections TDictionary(5): 多种 Create 手段uses Generics.Collections, Generics.Defaults;//Create 可以指定元素数, 这样可以提前分配空间以加快速度procedure TForm1.Button1Click(Sender: TObject);varDictionary: TDictionary<string,Integer>;beginDictionary := TDictionary<string,Integer>.Create(3);Dictionary.Add('n1', 111);Dictionary.Add('n2', 222);Dictionary.Add('n3', 333);Dictionary.Free;end;//Create 可以有一个 IEqualityComparer 参数, 用于判断 Key 怎样才是相同procedure TForm1.Button2Click(Sender: TObject);varDictionary: TDictionary<string,Integer>;EqualityComparer: IEqualityComparer<string>; {相等对比器}begin{通过 IEqualityComparer 让 TDictionary 的 Key 忽略大小写}EqualityComparer := TEqualityComparer<string>.Construct( function(const Left, Right: string): Boolean beginResult := LowerCase(Left) = LowerCase(Right);end,function(const Value: string): Integer beginResult := StrToIntDef(Value, 0); {我暂时不知道这个函数的作用, 随便写的}end);Dictionary := TDictionary<string,Integer>.Create(EqualityComparer); Dictionary.Add('n1', 111);Dictionary.Add('n2', 222);Dictionary.Add('n3', 333);{如果不是如上建立, 下面这句将会产生一个新元素, 而不是更新 n1 的值} Dictionary.AddOrSetValue('N1', 123);ShowMessage(IntToStr(Dictionary['n1'])); {123}Dictionary.Free;end;//Create 可以同时指定上面两个参数procedure TForm1.Button3Click(Sender: TObject);varDictionary: TDictionary<string,Integer>;EqualityComparer: IEqualityComparer<string>;beginEqualityComparer := TEqualityComparer<string>.Construct( function(const Left, Right: string): Boolean beginResult := LowerCase(Left) = LowerCase(Right);end,function(const Value: string): Integer beginResult := StrToIntDef(Value, 0);end);Dictionary := TDictionary<string,Integer>.Create(9, EqualityComparer);Dictionary.Add('n1', 111);Dictionary.AddOrSetValue('N1', 123);ShowMessage(IntToStr(Dictionary['n1'])); {123}{指定元素数后, 用不了的可以释放}Dictionary.TrimExcess;Dictionary.Free;end;//可通过另一个 TDictionary 建立一个新的 TDictionaryprocedure TForm1.Button4Click(Sender: TObject);varDictionary, DictionaryTmp: TDictionary<string,Integer>;pair: TPair<string,Integer>;beginDictionaryTmp := TDictionary<string,Integer>.Create();DictionaryTmp.Add('n1', 111);DictionaryTmp.Add('n2', 222);DictionaryTmp.Add('n3', 333);{通过另一个 TDictionary 建立}Dictionary := TDictionary<string,Integer>.Create(DictionaryTmp); {遍历看看}for pair in Dictionary doShowMessage(IntToStr(Dictionary[pair.Key]));{222 333 111}DictionaryTmp.Free;Dictionary.Free;end;//通过另一个 TDictionary 建立时, 可同时再指定 "相等对比器" procedure TForm1.Button5Click(Sender: TObject);varDictionary, DictionaryTmp: TDictionary<string,Integer>;pair: TPair<string,Integer>;EqualityComparer: IEqualityComparer<string>;beginDictionaryTmp := TDictionary<string,Integer>.Create();DictionaryTmp.Add('n1', 111);DictionaryTmp.Add('n2', 222);DictionaryTmp.Add('n3', 333);{再做个对比器}EqualityComparer := TEqualityComparer<string>.Construct( function(const Left, Right: string): Boolean beginResult := LowerCase(Left) = LowerCase(Right);end,function(const Value: string): Integer beginResult := StrToIntDef(Value, 0);end);{通过另一个 TDictionary 建立, 同时更换对比器}Dictionary := TDictionary<string,Integer>.Create(DictionaryTmp, EqualityComparer);{测试对比器}Dictionary.AddOrSetValue('N1', 999);{遍历看看}for pair in Dictionary doShowMessage(IntToStr(Dictionary[pair.Key]));{222 333 999}DictionaryTmp.Free;Dictionary.Free;end;详测 Generics Collections TListuses Generics.Collections;procedure TForm1.Button1Click(Sender: TObject);varList: TList<Cardinal>;i: Integer;str: string;beginList := TList<Cardinal>.Create();{Add}List.Add(22);List.Add(33);List.Add(11);{Count、Capacity }ShowMessageFmt('Count: %d; Capacity: %d', [List.Count,List.Capacity]);str := '';for i in List do str := str + UIntToStr(i) + sLineBreak;ShowMessage(str);{Clear}List.Clear;ShowMessageFmt('Count: %d; Capacity: %d', [List.Count,List.Capacity]);List.Free;end;// First、Last、IndexOf、LastIndexOfprocedure TForm1.Button2Click(Sender: TObject);varList: TList<string>;beginList := TList<string>.Create();List.Add('AA');List.Add('BB');List.Add('CC');List.Add('BB');List.Add('DD');ShowMessageFmt('First: %s', [List.First]); {First: AA}ShowMessageFmt('Last: %s', [st]); {Last: DD}ShowMessageFmt('IndexOf: %d', [List.IndexOf('BB')]); {IndexOf: 1}ShowMessageFmt('LastIndexOf: %d', [stIndexOf('BB')]); {LastIndexOf: 3}List.Free;end;// Insert、Delete、Remove、Extractprocedure TForm1.Button3Click(Sender: TObject);varList: TList<Integer>;i: Integer;str: string;beginList := TList<Integer>.Create();List.Add(111);List.Add(222);List.Add(333);List.Insert(0, 444);List.Insert(2, 555);str := '';for i in List do str := str + UIntToStr(i) + ' '; {444 111 555 222 333 } ShowMessage(str);List.Delete(0);List.Delete(List.Count-1);str := '';for i in List do str := str + UIntToStr(i) + ' '; {111 555 222 }ShowMessage(str);List.Remove(555); {删除指定元素}str := '';for i in List do str := str + UIntToStr(i) + ' '; {111 222 }ShowMessage(str);List.Extract(222); {提取指定元素}str := '';for i in List do str := str + UIntToStr(i) + ' '; {111 }ShowMessage(str);List.Free;end;// AddRange、InsertRange、DeleteRangeprocedure TForm1.Button4Click(Sender: TObject);varList,ListTmp: TList<Byte>;i: Byte;str: string;beginList := TList<Byte>.Create();List.AddRange([11,22,33]);str := '';for i in List do str := str + IntToStr(i) + ' '; {11 22 33 }ShowMessage(str);ListTmp := TList<Byte>.Create();ListTmp.AddRange([44,55]);List.AddRange(ListTmp);str := '';for i in List do str := str + IntToStr(i) + ' '; {11 22 33 44 55 } ShowMessage(str);List.InsertRange(1, ListTmp);str := '';for i in List do str := str + IntToStr(i) + ' '; {11 44 55 22 33 44 55 } ShowMessage(str);List.DeleteRange(1, 5);str := '';for i in List do str := str + IntToStr(i) + ' '; {11 55 }ShowMessage(str);ListTmp.Free;List.Free;end;// Move、Exchangeprocedure TForm1.Button5Click(Sender: TObject);varList: TList<Byte>;b: Byte;str: string;beginList := TList<Byte>.Create();List.AddRange([11,22,33,44]);List.Move(1, 2);str := '';for b in List do str := str + IntToStr(b) + ' '; {11 33 22 44 }ShowMessage(str);List.Exchange(0, 3);str := '';for b in List do str := str + IntToStr(b) + ' '; {44 33 22 11 }ShowMessage(str);List.Free;end;// Reverse、TrimExcessprocedure TForm1.Button6Click(Sender: TObject);varList: TList<Byte>;b: Byte;str: string;beginList := TList<Byte>.Create();List.Add(11);List.Add(22);List.Add(33);str := '';for b in List do str := str + IntToStr(b) + ' '; {11 22 33 } ShowMessage(str);List.Reverse;str := '';for b in List do str := str + IntToStr(b) + ' '; {33 22 11 } ShowMessage(str);ShowMessage(IntToStr(List.Capacity)); {4}List.TrimExcess;ShowMessage(IntToStr(List.Capacity)); {3}List.Free;end;// Items、Containsprocedure TForm1.Button7Click(Sender: TObject);varList: TList<string>;b: Boolean;beginList := TList<string>.Create();List.AddRange(['AA', 'BB', 'CC']);ShowMessageFmt('%s : %s', [List[1], List.Items[1]]); {BB : BB} b := List.Contains('BB');ShowMessage(BoolToStr(b, True)); {True}b := List.Contains('DD');ShowMessage(BoolToStr(b, True)); {False}List.Free;end;// Sortuses Generics.Collections, Generics.Defaults;procedure TForm1.Button1Click(Sender: TObject);varList: TList<Integer>;i: Integer;str: string;beginList := TList<Integer>.Create();List.AddRange([22,33,11]);str := '';for i in List do str := str + IntToStr(i) + ' ';ShowMessage(str); {22 33 11 }{排序}List.Sort;str := '';for i in List do str := str + IntToStr(i) + ' ';ShowMessage(str); {11 22 33 }{倒排序}List.Sort(TComparer<Integer>.Construct(function (const n1,n2: Integer): IntegerbeginResult := n2 - n1;end));str := '';for i in List do str := str + IntToStr(i) + ' ';ShowMessage(str); {33 22 11 }List.Free;end;// BinarySearchuses Generics.Collections, Generics.Defaults;procedure TForm1.Button1Click(Sender: TObject);varList: TList<string>;num: Integer;b: Boolean;Comparer: IComparer<string>;beginList := TList<string>.Create();List.AddRange(['123', 'ABB', 'ABC']);{默认的查找需要完全吻合才能找到}if List.BinarySearch('ABC', num) then ShowMessage(IntToStr(num)); {2} {这里自定义个对比器, 只要第一个字符吻合就算找到了}Comparer := TComparer<string>.Construct(function(const s1,s2: string): IntegerbeginResult := Ord(s1[1]) - Ord(s2[1]);end);if List.BinarySearch('ABC', num, Comparer) thenShowMessage(IntToStr(num)); {1}List.Free;end;// OnNotify 事件interfaceusesGenerics.Collections;implementation{准备给 List.OnNotify 调用的事件过程}procedure TForm1.MyListNotify(Sender: TObject; const Item: string; Action: TCollectionNotification);begincase Action ofcnAdded : ShowMessageFmt('Add: %s', [Item]);cnRemoved : ShowMessageFmt('Remove: %s', [Item]);cnExtracted : ShowMessageFmt('Extract: %s', [Item]);end;end;procedure TForm1.Button1Click(Sender: TObject);varList: TList<string>;beginList := TList<string>.Create();List.OnNotify := MyListNotify; {关联事件过程}List.AddRange(['A', 'B', 'C']); {Add: A | Add: B | Add: C }List.Delete(0); {Remove: A}List.Remove('B'); {Remove: B}List.Extract('C'); {Extract: C}List.OnNotify := nil;List.Free;end;// Createuses Generics.Collections, Generics.Defaults;vari: Integer;str: string;//无参数的建立procedure TForm1.Button1Click(Sender: TObject); varList: TList<Integer>;beginList := TList<Integer>.Create();List.AddRange([11,22,33]);str := '';for i in List do str := str + IntToStr(i) + ' '; ShowMessage(str); {11 22 33 }List.Free;end;//可以基于另一个列表建立procedure TForm1.Button2Click(Sender: TObject); varList,ListTmp: TList<Integer>;beginListTmp := TList<Integer>.Create();ListTmp.AddRange([1, 2, 3]);List := TList<Integer>.Create(ListTmp);str := '';for i in List do str := str + IntToStr(i) + ' '; ShowMessage(str); {1 2 3 }ListTmp.Free;List.Free;end;//可在建立时同时指定排序器procedure TForm1.Button3Click(Sender: TObject); varList: TList<Integer>;Comparer: IComparer<Integer>;begin{建立排序器}Comparer := TComparer<Integer>.Construct( function(const n1,n2: Integer): IntegerbeginResult := n2 - n1;end);List := TList<Integer>.Create(Comparer);List.AddRange([2, 3, 1]);List.Sort; {会根据建立时指定的排序器排序}str := '';for i in List do str := str + IntToStr(i) + ' '; ShowMessage(str); {3 2 1 }List.Free;end;泛型排序器 TComparerunit Unit1;interfaceusesWindows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;typeTForm1 = class(TForm)Memo1: TMemo;Memo2: TMemo;Button1: TButton;Button2: TButton;Button3: TButton;Button4: TButton;Button5: TButton;Button6: TButton;Button7: TButton;Button8: TButton;Button9: TButton;Button10: TButton;procedure Button1Click(Sender: TObject);procedure Button2Click(Sender: TObject);procedure Button3Click(Sender: TObject);procedure Button4Click(Sender: TObject);procedure Button5Click(Sender: TObject);procedure Button6Click(Sender: TObject);procedure Button7Click(Sender: TObject);procedure Button8Click(Sender: TObject);procedure Button9Click(Sender: TObject);procedure Button10Click(Sender: TObject);end;varForm1: TForm1;implementation{$R *.dfm}uses Generics.Collections, Generics.Defaults; {必需的泛型单元}//构建由 10 个整数组成的动态数组, 然后排序procedure TForm1.Button1Click(Sender: TObject);vararr: array of Integer;i: Integer;begin{构建动态数组}Randomize;for i := 0to9do beginSetLength(arr, Length(arr)+1);arr[i] := Random(10);end;{显示排序前}Memo1.Clear;for i := 0to Length(arr) - 1do Memo1.Lines.Add(IntToStr(arr[i])); {排序}TArray.Sort<Integer>(arr); {它可以有 1个、2个、4个参数, 这里只用了一个参数, 其他是默认参数}{显示排序结果}Memo2.Clear;for i := 0to Length(arr) - 1do Memo2.Lines.Add(IntToStr(arr[i])); end;// TArray.Sort 的第二个参数是 IComparer<T> 类型, 其默认值是: TComparer<T>.Defaultprocedure TForm1.Button2Click(Sender: TObject);vararr: array of Integer;i: Integer;beginRandomize;for i := 0to9do beginSetLength(arr, Length(arr)+1);arr[i] := Random(10);end;Memo1.Clear;for i := 0to Length(arr) - 1do Memo1.Lines.Add(IntToStr(arr[i])); {使用了排序器的默认值排序, 这和忽略这个参数是一样的}TArray.Sort<Integer>(arr, TComparer<Integer>.Default);Memo2.Clear;for i := 0to Length(arr) - 1do Memo2.Lines.Add(IntToStr(arr[i])); end;//同上两例, 变通了一下写法procedure TForm1.Button3Click(Sender: TObject);vararr: array of Integer;i: Integer;Comparer: IComparer<Integer>;beginRandomize;for i := 0to9do beginSetLength(arr, Length(arr)+1);arr[i] := Random(10);end;Memo1.Clear;for i := 0to Length(arr) - 1do Memo1.Lines.Add(IntToStr(arr[i])); Comparer := TComparer<Integer>.Default;TArray.Sort<Integer>(arr, Comparer);Memo2.Clear;for i := 0to Length(arr) - 1do Memo2.Lines.Add(IntToStr(arr[i])); end;// TArray.Sort 的后面两个参数可以指定排序范围:procedure TForm1.Button4Click(Sender: TObject);vararr: array of Integer;i: Integer;Comparer: IComparer<Integer>;beginRandomize;for i := 0to9do beginSetLength(arr, Length(arr)+1);arr[i] := Random(10);end;Memo1.Clear;for i := 0to Length(arr) - 1do Memo1.Lines.Add(IntToStr(arr[i])); Comparer := TComparer<Integer>.Default;{这里指定从第 1 个元素开始, 只给 3 个元素排序}TArray.Sort<Integer>(arr, Comparer, 0, 3);Memo2.Clear;for i := 0to Length(arr) - 1do Memo2.Lines.Add(IntToStr(arr[i])); end;//如果要倒排序, 可以建立自己的排序器, 下面就是先构建并实现了一个TMyComparer, 然后调用:typeTMyComparer = class(TComparer<Integer>)publicfunction Compare(const Left, Right: Integer): Integer; override; end;{ TMyComparer }function pare(const Left, Right: Integer): Integer;beginResult := Right - Left;end;procedure TForm1.Button5Click(Sender: TObject);vararr: array of Integer;i: Integer;Comparer: TMyComparer;beginRandomize;for i := 0to9do beginSetLength(arr, Length(arr)+1);arr[i] := Random(10);end;Memo1.Clear;for i := 0to Length(arr) - 1do Memo1.Lines.Add(IntToStr(arr[i])); Comparer := TMyComparer.Create;TArray.Sort<Integer>(arr, Comparer);Memo2.Clear;for i := 0to Length(arr) - 1do Memo2.Lines.Add(IntToStr(arr[i])); Comparer.Free;end;// 也可以用 TComparer<T>.Construct 方法, 通过一个 TComparison 格式的函数构建排序器, 这样简单一些function MyFunc1(const Left, Right: Integer): Integer;beginResult := Right - Left;end;procedure TForm1.Button6Click(Sender: TObject);vararr: array of Integer;i: Integer;Comparer: IComparer<Integer>;beginRandomize;for i := 0to9do beginSetLength(arr, Length(arr)+1);arr[i] := Random(10);end;Memo1.Clear;for i := 0to Length(arr) - 1do Memo1.Lines.Add(IntToStr(arr[i]));Comparer := TComparer<Integer>.Construct(MyFunc1);TArray.Sort<Integer>(arr, Comparer);Memo2.Clear;for i := 0to Length(arr) - 1do Memo2.Lines.Add(IntToStr(arr[i])); end;//如果是给自定义类型的元素排序, 只能是自建排序器typeTPerson = recordname: string;age: Word;end;function MyFunc2(const Left, Right: TPerson): Integer;beginResult := Left.age - Right.age;end;procedure TForm1.Button7Click(Sender: TObject);vararr: array of TPerson;i: Integer;Comparer: IComparer<TPerson>;beginSetLength(arr, 4);arr[0].name := 'AA'; arr[0].age := 22;arr[1].name := 'BB'; arr[1].age := 33;arr[2].name := 'CC'; arr[2].age := 44;arr[3].name := 'DD'; arr[3].age := 11;Memo1.Clear;for i := 0to Length(arr) - 1doMemo1.Lines.Add(Format('%s : %d', [arr[i].name, arr[i].age]));Comparer := TComparer<TPerson>.Construct(MyFunc2);TArray.Sort<TPerson>(arr, Comparer);Memo2.Clear;for i := 0to Length(arr) - 1doMemo2.Lines.Add(Format('%s : %d', [arr[i].name, arr[i].age])); end;// TStringComparer.Ordinal 是官方实现的用于 string 的排序器, 可直接使用.//但它好像有问题(Delphi 2010 - 14.0.3513.24210), 以后的版本应该能改过来.procedure TForm1.Button8Click(Sender: TObject);vararr: array of string;i: Integer;beginSetLength(arr, 4);arr[0] := '222';arr[1] := '111';arr[2] := 'bbb';arr[3] := 'aaa';Memo1.Clear;for i := 0to Length(arr) - 1do Memo1.Lines.Add(arr[i]); TArray.Sort<string>(arr, TStringComparer.Ordinal);Memo2.Clear;for i := 0to Length(arr) - 1do Memo2.Lines.Add(arr[i]); end;//下面是实现字符串数组的到排序function MyComparerFunc(const s1,s2: string): Integer;beginResult := CompareText(s2, s1);//Result := -CompareText(s1, s2); {或者这样}end;procedure TForm1.Button9Click(Sender: TObject);vararr: array of string;i: Integer;Comparer: IComparer<string>;beginMemo1.Clear;maText := '11,33,22,AAA,CCC,BBB';SetLength(arr, Memo1.Lines.Count);for i := 0to Length(arr) - 1do arr[i] := Memo1.Lines[i]; Comparer := TComparer<string>.Construct(MyComparerFunc); TArray.Sort<string>(arr, Comparer);Memo2.Clear;for i := 0to Length(arr) - 1do Memo2.Lines.Add(arr[i]); end;//可以把上一个程序简写为:procedure TForm1.Button10Click(Sender: TObject);vararr: array of string;i: Integer;Comparer: IComparer<string>;beginMemo1.Clear;maText := '11,33,22,AAA,CCC,BBB';SetLength(arr, Memo1.Lines.Count);for i := 0to Length(arr) - 1do arr[i] := Memo1.Lines[i]; Comparer := TComparer<string>.Construct(function (const s1,s2: string): IntegerbeginResult := CompareText(s2, s1);end);TArray.Sort<string>(arr, Comparer);Memo2.Clear;for i := 0to Length(arr) - 1do Memo2.Lines.Add(arr[i]); end;。

算法之字典排序法2. 字典序法字典序法就是按照字典排序的思想逐一产生所有排列.设想要得到由1,2,3,4以各种可能次序产生出4!个“单词”. 肯定先排1234, 再排1243, 下来是1324, 1342, …., 4321.分析这种过程, 看如何由一个排列得到下一个排列, 并给出严格的数学描述.例2.3 设有排列(p) =2763541, 按照字典式排序, 它的下一个排列是?(q) =2764135.(1) 2763541 [找最后一个正序35](2) 2763541 [找3后面比3大的最后一个数](3) 2764531 [交换3,4的位置](4) 2764135 [把4后面的531反序排列为135即得到最后的排列(q)]求(p)=p1⋯p i-1p i…p n的下一个排列(q):(1) 求i=max{j⎪ p j-1<p j}(找最后一个正序)(2) 求j=max{k⎪ p i-1<p k}(找最后大于p i-1者)(3) 互换p i-1与p j得p1…p i-2 p j p i p i+1⋯p j-1 p i-1 p j+1…p n(4) 反排p j后面的数得到(q):p1…p i-2 p j p n⋯p j+1p i-1p j-1 ….p i+1 p i例2.4 设S={1,2,3,4}, 用字典序法求出S的全部排列. 解1234, 1243, 1324, 1342, 1423, 1432,2134, 2143, 2314, 2341, 2413, 2431,3124, 3142, 3214, 3241, 3412, 3421,4123, 4132, 4213, 4231, 4312, 4321.字典排序法C++代码：#include<iostream.h>void repailie(int *a,int n,int dp){int *bb=new int[n-dp];int *cc=new int[n-dp];int ti=0;for(int i=dp+1;i<n;i++){bb[ti++]=a[i];}for(int j=0;j<ti;j++){a[j+dp+1]=bb[ti-j-1];}//cout<<a[dp+1]<<" ";//cout<<endl;}int main(void){int n;cout<<"请输入1至无穷大的数"<<endl;cin>>n;int *a=new int[n];int p=1;//n的阶层int q=1;//循环记录int b,c;//最后一对正序int bi,ci;//记录b和c的位置int d;//最后大于b者int di;//记录d的位置for (int o=1;o<=n;o++){p=p*o;//cout<<p<<" ";}for (int i=0;i<n;i++){a[i]=i+1;cout<<a[i]<<" ";}cout<<endl;while(q<p){for(int j=n-1;j>=0;j--){if(a[j-1]<a[j]){b=a[j-1];bi=j-1;c=a[j];ci=j;break;}}//cout<<bi<<" "<<ci<<" "<<endl;for(int k=n-1;k>=0;k--)if (a[k]>b){d=a[k];di=k;break;}}//cout<<di<<endl;for(int l=0;l<n;l++){if(l==di){a[l]=b;//cout<<a[l]<<endl;}if(l==bi){a[l]=d;//cout<<a[l]<<endl;}repailie(a,n,bi);for (int m=0;m<n;m++){cout<<a[m]<<" ";}cout<<endl;++q;}}运行结果图：。

字典排序法
字典排序法是一种常见的排序算法，它可以将一组乱序的数字或字母按照字典序排列起来。

它使用字母表或词典来比较元素，以确定它们之间的序列关系。

它的基本思想是，将一个无序的数组重新排列为字典排序的有序数组，以使得相同的元素总是相邻，并且相对排列顺序也是相同的。

字典排序法是一种比较排序，它的实现有两种主要的方法：直接排序法和桶式排序法。

在直接排序法中，它首先比较每个元素，根据字母表或词典将它放入一个有序表中，直到所有元素都排序完毕为止。

在桶式排序法中，它首先将元素划分到不同的桶中，然后再把这些桶中的元素依次放入有序表，直到所有元素都排序完毕为止。

字典排序法最重要的优势之一是其简单直观的操作，使得它可以轻松实现。

它可以被用来处理的问题非常多，包括数据库的查询，排列组合等。

此外，它也可以被用来分析和比较数据，也可以被用来排序字符串，这是因为它可以将字母表或词典中的字符按照其正确的顺序进行排序，这有助于构建搜索引擎，以帮助用户更快、更有效地定位信息。

另外，它具有稳定性。

当两个元素在字母表或词典中具有相同的序列时，它们的相对位置也不会改变，因此字典排序法具有稳定性。

同时，它的时间复杂度也比较低，只需要一次遍历就能够完成排序。

字典排序法由于其简单易懂和高效的原因，被广泛应用在各种领域，如数据挖掘，数据分析，文件系统，搜索引擎，排列组合等等。

因此，字典排序法对于确保数据的正确性和搜索引擎的高效是非常重要的。

总而言之，字典排序法是一种非常有效且易于实现的排序算法，它可以帮助我们处理各种相关问题，确保数据的正确性和搜索引擎的高效，从而提高效率。

sorted函数排序规则排序是数据处理领域中的一个重要步骤，针对不同的排序需求，使用不同的排序方法。

Python中有多种排序方法，其中sorted函数是最常用且简单易懂的一个。

sorted函数的基本用法如下：```pythonsorted(iterable, key=None, reverse=False)```其中，iterable是要进行排序的可迭代对象，key是一个函数，用来作为排序的规则，reverse是一个Bool类型的参数，在为True的情况下表示降序排序。

下面让我们详细探讨一下sorted函数的排序规则。

1.按元素大小排序sorted函数默认以元素值大小进行排序，如下：```python>>> nums = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]>>> sorted_nums = sorted(nums)>>> print(sorted_nums)[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]```2.按元素长度排序如果要按元素的长度进行排序，可以使用key参数指定一个计算元素长度的函数，如下：```python>>> strings = ['apple', 'banana', 'orange', 'grape','watermelon']>>> sorted_strings = sorted(strings, key=lambda x: len(x)) >>> print(sorted_strings)['grape', 'apple', 'banana', 'orange', 'watermelon']```这里使用了Python的lambda表达式，实现了对字符串长度的计算。