下载文档原格式
JAVA关于String的CompareTo⽅法即字典序⽐较按字典顺序⽐较两个字符串。
该⽐较基于字符串中各个字符的 Unicode 值。
将此String对象表⽰的字符序列与参数字符串所表⽰的字符序列进⾏⽐较。
如果按字典顺序此String对象在参数字符串之前，则⽐较结果为⼀个负整数。
如果按字典顺序此String对象位于参数字符串之后，则⽐较结果为⼀个正整数。
如果这两个字符串相等，则结果为 0；compareTo只有在⽅法equals(Object)返回true时才返回0。
这是字典排序的定义。
如果这两个字符串不同，则要么它们在某个索引处具有不同的字符，该索引对⼆者均为有效索引，要么它们的长度不同，或者同时具备上述两种情况。
如果它们在⼀个或多个索引位置上具有不同的字符，假设k是这类索引的最⼩值；则按照 < 运算符确定的那个字符串在位置k上具有较⼩的值，其字典顺序在其他字符串之前。
这种情况下，compareTo返回这两个字符串在位置k处的两个不同的char 值，即值：this.charAt(k)-anotherString.charAt(k)如果它们没有不同的索引位置，则较短字符串在字典顺序上位于较长字符串的前⾯。
这种情况下，compareTo返回这两个字符串长度的不同，即值：this.length()-anotherString.length()Java代码1. public class TestStringCompare {2. public static void main(String args[])3. {4. String s1="abc";5. String s2="abcd";6. System.out.println("pareTo(s2)"+pareTo(s2));//前缀相同则⽐较长度，长度差-17. System.out.println("pareTo(s2)"+pareTo("abcdefgh"));//长度差-58. String s3="abc";9. String s4="ae";10. System.out.println("pareTo(s4)"+pareTo(s4));//只⽐较第⼀个不同的字符处b-e=-311. String s5="abcdeg";12. String s6="acce";13. System.out.println("pareTo(s6)"+pareTo(s6));//b-c=-114. String s7="abc";15. String s8="abb";16. System.out.println("pareTo(s8)"+pareTo(s8));//c-b=117. String s9="abc";18. String s0="abaaaaaaaaaaaaa";19. System.out.println("pareTo(s0)"+pareTo(s0));//c-a=2只⽐较第⼀个不同的字符处，与长度⽆关20.21. String sa="我";22. System.out.println("pareTo(s0)"+pareTo("喔"));//-2181因为是Unicode编码可以⽐较汉字23. }24.25. }。
Java是一种广泛应用的编程语言，数字字符串在Java中也有特定的比较大小规则。
下面将通过以下主题和内容逐步介绍Java中数字字符串比较大小的规则。
一、数字字符串比较大小的规则简介在Java中，数字字符串比较大小的规则是按照字符串的字典顺序进行比较的。
即依次比较字符串中每个字符的Unicode值大小，直到找到不同的字符或者某一个字符串结束为止。
这意味着在比较数字字符串时，实际上是在比较字符串的字母顺序，而不是比较数字的大小。
二、数字字符串比较大小的示例为了更好地理解数字字符串比较大小的规则，我们可以通过以下示例进行说明。
示例1：比较"123"和"456"两个数字字符串的大小。
按照规则，首先比较字符串中第一个字符的Unicode值，即'1'和'4'，发现'1'的Unicode值小于'4'，因此"123"小于"456"。
示例2：比较"100"和"99"两个数字字符串的大小。
在这个示例中，首先比较字符串中第一个字符的Unicode值，即'1'和'9'，发现'1'的Unicode值大于'9'，因此"100"大于"99"。
通过以上示例可以看出，虽然我们在比较的是数字字符串，但实际上是按照字符串的字典顺序进行比较的。
三、数字字符串的比较方法在Java中，可以使pareTo方法来比较数字字符串的大小。
该方法是由String类提供的，用于比较两个字符串的大小。
示例3：使pareTo方法比较数字字符串的大小。
```javaString str1 = "123";String str2 = "456";int result = str1pareTo(str2);if(result < 0){System.out.println("str1小于str2");}else if(result > 0){System.out.println("str1大于str2");}else{System.out.println("str1等于str2");}```通过调pareTo方法可以方便地比较两个数字字符串的大小，并根据比较结果进行相应的处理。
组合排序的算法组合排序是一种算法，它通过将一组对象以不同的方式组合来生成一个排列，这些排列按照一定的顺序进行排序。
这种算法在实际应用中非常重要，可以用于排列组合问题、数据压缩、信息检索等领域。
1.基本概念组合排序是一种算法，它通过将一组对象以不同的方式组合来生成一个排列，这些排列按照一定的顺序进行排序。
在组合问题中，我们需要对一组元素进行排列组合，以便生成所有可能的排列（或组合）。
例如，对于元素{A,B,C}，可以产生的所有排列为：ABC, ACB, BAC, BCA, CAB和CBA。
组合排序算法是一种用于生成这些排列（或组合）的有效方法。
2.算法描述组合排序算法基于递归的思想，将问题的规模逐渐减小，以便解决问题。
具体地，算法描述如下：（1）选择n个元素中的一个元素，作为当前排列的第一个元素；（3）将这些元素按照字典序排列；（4）递归地调用步骤（2）和（3），直到生成了所有可能的排列。
3.示例代码以下是一组使用Java编写的组合排序算法的示例代码：public static void permutation(String str) {permutation("", str);}private static void permutation(String prefix, String str) {int n = str.length();if (n == 0) System.out.println(prefix);else {for (int i = 0; i < n; i++)permutation(prefix + str.charAt(i), str.substring(0, i) +str.substring(i+1, n));}}在上述代码中，permutation()是一个递归函数，它依次将字符串中的每个字符作为当前排列的第一个元素，并生成所有可能的子排列。
java字典用法Java字典是一种键值对的数据结构，也被称为映射或关联数组。
它提供了一个快速查找和访问值的方法，通过使用唯一的键来索引和存储值。
在Java中，字典是通过Map接口实现的，有多个内置的实现类可以选择，如HashMap、TreeMap和LinkedHashMap。
1. 创建字典对象在Java中，可以使用Map接口的实现类来创建字典对象。
例如，可以使用HashMap来创建一个空的字典对象：```Map<String, Integer> dictionary = new HashMap<>();```在这个例子中，字典的键是字符串类型，值是整数类型。
根据字典的需求，可以根据实际情况选择使用不同的键和值类型。
2. 添加键值对可以使用`put(key, value)`方法向字典中添加键值对。
例如，将一个键为"apple"，值为5的键值对添加到字典中：```dictionary.put("apple", 5);```可以添加多个键值对到同一个字典中。
3. 获取值可以使用`get(key)`方法根据键来获取值。
例如，通过键"apple"获取值：```int value = dictionary.get("apple");```如果键不存在于字典中，`get()`方法将返回null。
4. 检查键是否存在可以使用`containsKey(key)`方法来检查字典中是否存在某个键。
例如，检查是否存在键"apple"：```boolean exists = dictionary.containsKey("apple");```如果存在，`exists`将被设置为true，否则为false。
5. 更新键值对可以使用`put(key, value)`方法来更新字典中的键值对。
字典序问题的算法代码字典序问题是指给定一个字符串，求出其所有的字典序排列。
例如，对于字符串"abc"，其字典序排列为"abc"、"acb"、"bac"、"bca"、"cab"和"cba"。
解决字典序问题的一种常见算法是回溯法。
回溯法是一种通过不断尝试所有可能的解，并在不满足条件时进行回溯的算法。
下面是一个使用回溯法解决字典序问题的算法代码：```pythondef backtrack(s, path, used, res):# 如果已经遍历完整个字符串s，则将当前排列加入结果列表if len(path) == len(s):res.append(''.join(path))returnfor i in range(len(s)):# 如果当前字符已经被使用过，则跳过if used[i]:continue# 将当前字符加入排列中path.append(s[i])used[i] = True# 递归调用回溯函数，继续向下一个字符进行排列 backtrack(s, path, used, res)# 回溯，将当前字符从排列中移除path.pop()used[i] = Falsedef dictionary_order(s):res = []path = []used = [False] * len(s)# 调用回溯函数，得到所有的字典序排列backtrack(s, path, used, res)return res# 测试代码s = "abc"result = dictionary_order(s)print(result)```在上述代码中，我们定义了一个回溯函数`backtrack`，该函数用于生成所有的字典序排列。
函数的参数包括当前的字符串`s`，当前的排列`path`，记录字符是否被使用的列表`used`，以及存储结果的列表`res`。
字典序的定义-概述说明以及解释1.引言1.1 概述字典序是一种排序方法，它基于字母或数字的顺序，按照从左到右的顺序逐个比较字符或数字的大小。
在字典序中，首先比较第一个字符或数字，如果相同，则继续比较第二个字符或数字，以此类推，直到找到不同的字符或数字为止。
根据比较结果来确定其在序列中的位置。
字典序在日常生活中非常常见，我们在查看字典、电话簿、学生名单等时经常会遇到。
它不仅在实际应用中具有很大的作用，而且在计算机科学中也是一个重要的概念。
字典序的应用非常广泛，如字符串排序、搜索引擎排序算法、数据库索引等。
在字符串排序中，我们可以使用字典序将字符串按照字母顺序进行排序，这对于进行字符串的查找和比较非常有帮助。
在搜索引擎中，字典序能够根据搜索关键词的字母顺序将搜索结果进行排序，提高搜索效率。
而数据库索引则可以使用字典序对数据库中的数据进行排序和查找。
本文将重点介绍字典序的定义和应用，通过对字典序的深入了解，可以更好地理解其在实际生活和计算机科学中的重要性和应用价值。
同时，本文还将展望字典序在未来的发展趋势，探讨其在更多领域中的应用前景。
1.2文章结构1.2 文章结构本文将按照以下结构进行叙述：第一部分是引言。
引言主要包括三个部分：概述、文章结构和目的。
在概述中，将简要介绍字典序的概念和重要性。
文章结构部分将对整篇文章的组织结构进行说明，提供读者整体了解文章脉络的导引。
目的部分说明本文撰写的目的，明确了解字典序定义和应用的重要性。
第二部分是正文。
正文包括两个部分：字典序的定义和字典序的应用。
其中，字典序的定义部分将详细解释字典序的含义、定义和特点。
此部分将探讨字典序如何根据字母表的排列顺序进行排序，以及如何应用于不同的情境中。
字典序的应用部分将探讨字典序在实际生活中的各种应用，如字符串排序、排列组合问题等。
将通过实例和案例来说明字典序在不同领域中的实际应用，并探讨其优势和局限性。
第三部分是结论。
结论部分将总结全文的主要观点和观点。
字典序排序规则字典序是一种常用的文本排序方法，也叫作字母排序、字符排序或词典顺序，它是指按照字符串中第一个字母的字母表顺序来排序。
它是一种通用的方法，可以用于排序不同语言中的字符串。
字典序排序规则可以分为三个基本概念：字母表顺序，比较原则和大小写规则。
字母表顺序是指排序时按照英文字母的出现次序来排列，如A，B，C，D，E，F，G，H，I，J，K，L，M，N，O，P，Q，R，S，T，U，V，W，X，Y，Z，以及分隔符。
比较原则是按照字符串中每个字符的字母表顺序来比较，比较的结果可以是相等、小于或者大于，这取决于字符串中比较字符的出现次序。
如果比较字符之间出现相等，就比较下一个字符。
这样就能确定字典序排序的位置。
大小写规则是指对于有些排序系统，小写字母比大写字母优先，反之大写字母比小写字母优先。
字典序排序规则可以用于排序各种字符串，包括单词表、英文文章、文件名、文件路径、网址和编程语言中的符号标识符。
它也可以用于查找文本中的某个字符串，例如使用搜索引擎搜索某个关键字时。
字典序排序规则也可以用于排序多种数据类型，如整数、日期和浮点数。
由于字符串和数字可以转换为一个字符串，因此可以将这些数据类型排序成字母序。
这样就可以利用字典序排序规则来比较多种数据类型。
字典序排序规则对于数据库、文件系统和其他应用有很多用处，它可以极大地提高检索准确性，也可以减少搜索所需的时间。
另外，字典序排序规则可以用于排序不可见的数据，这也有助于检索文本中的信息。
字典序排序是一种有用的排序算法，它可以应用于多种情境中，并帮助解决检索的效率问题。
它的好处是简单，易于理解，易于实现，可以应用于排序不同语言的字符串，以及各种数据类型，这些都使它成为一种非常流行的文本排序算法。
Java字符串排序方法介绍字符串在很多应用中都是一个重要的数据类型。
Java语言提供了多种方法来对字符串进行排序，以满足不同场景的需求。
本文将介绍几种常见的Java字符串排序方法。
目录1.字典序排序2.按字符串长度排序3.自定义排序规则4.忽略大小写排序5.多条件排序6.总结字典序排序字典序（lexicographical order）是根据字符在字母表中的顺序进行排序。
Java 的String类实现了Comparable接口，所以可以直接使用Collections类的sort方法进行字典序排序。
import java.util.ArrayList;import java.util.Collections;import java.util.List;public class LexicographicalOrder {public static void main(String[] args) {List<String> strings = new ArrayList<>();strings.add("apple");strings.add("banana");strings.add("cat");strings.add("dog");Collections.sort(strings);for (String str : strings) {System.out.println(str);}}}输出结果为：applebananacatdog通过调用Collections.sort方法，可以对字符串列表按字典序进行排序。
按字符串长度排序有时候需要根据字符串的长度进行排序，可以通过实现Comparator接口来自定义排序规则。
下面的例子演示了如何按照字符串长度进行排序。
import java.util.ArrayList;import java.util.Collections;import parator;import java.util.List;public class SortByLength {public static void main(String[] args) {List<String> strings = new ArrayList<>();strings.add("apple");strings.add("banana");strings.add("cat");strings.add("dog");Collections.sort(strings, new LengthComparator());for (String str : strings) {System.out.println(str);}}static class LengthComparator implements Comparator<String> {@Overridepublic int compare(String o1, String o2) {return o1.length() - o2.length();}}}输出结果为：catdogapplebanana自定义排序规则除了按照字典序和字符串长度排序，还可以根据其他要求定义自己的排序规则。
字典序最⼩问题给定长度为N的字符串S（只包含⼤写英⽂字母），要构造⼀个长度为N的字符串T。
起初，T是⼀个空串，随后反复进⾏下列任意操作。
从S的头部删除⼀个字符，加到T的尾部；从S的尾部删除⼀个字符，加到T的尾部。
⽬标是要构造字典序尽可能⼩的字符串T输⼊：第⼀⾏⼀个正整数N；后⾯N⾏，每⾏⼀个⼤写字母。
输出：T(输出时每⾏写满80个字符就换⾏)样例输⼊：6ACDBCB样例输出：ABCBCD限制条件：1≤N≤2000字符串S只包含⼤写英⽂字母解释：字典序是指从前到后⽐较两个字符串的⼤⼩的⽅法。
⾸先⽐较第⼀个字符，如果不同则第⼀个字符较⼩的字符串更⼩，如果相同则继续⽐较第2个字符......如此继续，来⽐较整个字符串的⼤⼩。
分析：贪⼼将字符串正序和反序⽐较，每次将较⼩串的⾸字母加到T的末尾！varn:integer;t,s1,s2:ansistring;ch:char;procedure init;var i:integer;beginreadln(n);s1:='';s2:='';for i:=1 to n dobeginreadln(ch);s1:=s1+ch;s2:=ch+s2;end;end;procedure main;var i:integer;beginfor i:=1 to n doif s1<s2 thenbegint:=t+s1[1];delete(s1,1,1);delete(s2,n-i+1,1);endelsebegint:=t+s2[1];delete(s1,n-i+1,1);delete(s2,1,1);end;end;procedure print;var i:integer;beginfor i:=1 to n dobeginwrite(t[i]);if i mod 80 =0 then writeln; end;end;begininit;main;PRINT;end.。
字符串的全排列（字典序排列）题⽬描述输⼊⼀个字符串，打印出该字符串中字符的所有排列。
例如输⼊字符串abc，则输出由字符a、b、c 所能排列出来的所有字符串abc, acb, bac, bca, cab, cba。
题⽬分析穷举与递归⼜是⼀个经典问题，最容易想到的解决⽅法仍然是穷举（我实在是太爱穷举法了，每当被问到算法问题不知道如何解决的时候，总可以祭出穷举⼤旗，从⽽多争取3分钟的思考时间）。
穷举虽好，但它⼤多数情况下都不是被需要的那个答案，是因为看起来代码太Low不够⾼⼤上吗？在这种情况下，穷举法裹着貂⽪⼤⾐的亲戚——递归就出现了。
虽然空间复杂度和时间复杂度没有任何改进，⽽且还增加了系统开销（关于递归法的系统开销不在这⾥讨论，之后再找专门的时间阐述），但是就是因为长得好看（代码看起来精炼），递归的B格⼉就⾼了很多。
递归法对于这个题⽬同样⾮常适⽤，基本思路就是固定⼀个字符，然后对剩余的字符做全排列……不赘述，请⾃⼰想。
如果你也跟我⼀样永远想不明⽩递归，那就画画图，写写代码，debug⼀下，每天花3-4个⼩时，静下⼼来仔细捉摸，总（ye）会（bu）想（hui）明⽩的。
贴⼀段July和他伙伴们在《程序员编程艺术：⾯试和算法⼼得》中的代码实现，供做噩梦时使⽤。
p.s. 我已加了注释/** Permute full array of input string by general recusion* @ char* perm [in/out] The string need to do permutation* @ int from [in] The start position of the string* @ int to [in] The end position of the string*/void CalcAllPermutation(char* perm, int from, int to){if (to <= 1){return;}if (from == to){//all characters has been permutedfor (int i = 0; i <= to; i++)cout << perm[i];cout << endl;}else{// always select one character, then full array the left ones.for (int j = from; j <= to; j++){swap(perm[j], perm[from]); //swap the selected character to the beginning of stringCalcAllPermutation(perm, from + 1, to); // Permute left characters in full array.swap(perm[j], perm[from]); //recovery the string to original one (swap the selected character back to its position.)}}}字典序这是⼀个⽐递归更有趣的答案，不知道算不算经典解法，起码开拓了思路，跟每⼀次接触新鲜的算法⼀样，仍然想了半天的时间，因此照例把思考过程更细致的记录下来（虽然July和他伙伴们在《程序员编程艺术：⾯试和算法⼼得》中已经说了很多），再加上⼀些⼩修改。
排列的字典序问题Problem Descriptionn个元素{1,2,...,n}有n!个不同的排列。
将这n!个排列按字典序排列并编号为0,1,...,n!-1。
每个排列的编号为其字典序值。
例如，当n=3时，6个不同排列的字典序值如下：字典序值012345排列123132213231312321给定n,以及n个元素{1,2,...,n}的⼀个排列，计算出这个排列的字典序值，以及按字典序排列的下⼀个排列。
Input输⼊包括多组数据。
每组数据的第⼀⾏是元素个数n(1<=n<=13),接下来1⾏是n个元素{1,2,...,n}的⼀个排列。
Output对于每组数据，输出两⾏，第⼀⾏是字典序值，第2⾏是字典序排列的下⼀个排列。
Sample Input8 2 6 4 5 8 1 7 3Sample Output82272 6 4 5 83 1 7-----------------------------------------------------------------此处为⽐较，可以掠过不看，直接下拉----------------------------------------------------------------------------------------------------------------------------排列的字典序，此题似乎与之前说过的类似，但是输⼊顺序有区别的。
输⼊123全排列输出：123132213231321312字典序输出：123132213231312321区别在于最后的两⾏，为什么会出现这样的情况呢？是因为在全排列问题时，利⽤的是对原数组进⾏替换。
初始：1 2 3交换[1] [3] ,则变成 3 2 1，再接下来的替换中，就按照 2 1进⾏的。
若想按照字典序输⼊，需要利⽤头尾数组算法。
建⽴两个数组 head,tail初始化head为空，tail 为n个顺序元素。
Java 数据结构面试问题
以下是一些可能在Java数据结构面试中出现的问题：
1. 什么是数据结构？
2. 请列举一些常见的数据结构类型。
3. 请解释堆栈（Stack）和队列（Queue）的区别。
4. 请解释数组（Array）和链表（Linked List）的区别。
5. 请解释哈希表（Hash Table）的原理和用途。
6. 请解释树（Tree）和图（Graph）的区别。
7. 请解释二叉树（Binary Tree）和二叉搜索树（Binary Search Tree）的区别。
8. 请解释深度优先搜索（Depth First Search）和广度优先搜索（Breadth First Search）的差异。
9. 请解释哈夫曼编码（Huffman Coding）的原理和应用。
10. 请解释红黑树（Red-Black Tree）的原理和特点。
11. 请解释Trie树（Trie Tree）的原理和用途。
12. 请解释图的表示方法，例如邻接矩阵和邻接表。
13. 请解释拓扑排序（Topological Sorting）的概念和应用。
14. 请解释堆（Heap）的原理和用途。
15. 请解释排序算法中的冒泡排序（Bubble Sort）和快速排序（Quick Sort）。
这只是一些可能的问题，实际面试中可能会有更多的问题。
在准备面试时，建议你熟悉这些数据结构的概念、原理和应用，并能够根据具体问题进行具体分析和解答。
字符串里最大字典序的子串摘要：1.引言：介绍字符串和子串的概念2.字典序的概念和重要性3.最大字典序子串的定义和求解方法4.例子和应用场景5.结论：总结最大字典序子串的意义和价值正文：一、引言在计算机科学中，字符串是一种常见的数据结构，用于表示文本信息。
子串是指字符串中的一个连续子序列，它在很多问题中都有着重要的应用。
而最大字典序子串则是指在所有子串中具有最大字典序的一个子串。
二、字典序的概念和重要性字典序，又称字母顺序或升序，是指字符串中字符的一种排序方式。
在字典序中，字母表中的每个字母都有一个固定的顺序，从a 到z（或从A 到Z）。
字典序在很多字符串处理问题中具有重要意义，因为它可以帮助我们快速比较两个字符串的大小。
三、最大字典序子串的定义和求解方法最大字典序子串是指在所有子串中具有最大字典序的一个子串。
求解最大字典序子串的方法有很多，其中一种比较常见的方法是动态规划。
动态规划是一种将原问题分解为若干子问题，并从子问题的解推导出原问题解的方法。
具体来说，对于一个字符串s，我们可以通过遍历字符串的每个位置，来求解以每个位置为结尾的最大字典序子串。
在遍历过程中，我们需要维护一个当前最大字典序子串的缓存，以便在遍历到新的位置时，可以快速更新最大字典序子串。
四、例子和应用场景举个例子，对于字符串"babad"，其最大字典序子串为"bab"，因为它在字典序中排在"aba"、"bba"等其他子串之前。
最大字典序子串在很多实际问题中都有着广泛的应用，比如在搜索引擎中，它可以帮助我们快速找到关键词的正确排序；在文本编辑器中，它可以用于自动排序和纠错等功能。
五、结论总结来说，最大字典序子串是字符串处理中的一个重要问题，它在很多实际应用中都具有很大的价值。
2字典序问题
1.1 算法设计思想
对于以字母i开头，长度为k的升序字符串，假设其个数为f（i，k），又假设长度为k的升序字符串总个数为g（k），则g（k）与f（i，k）存在一个函数关系，即g （k）=f（1,k）+f（2,k）+f（3，k）+ … +f（27-k，k）。
而f（i，k）也存在一条公式：f（i，k）=f（i+1，k-1）+f（i+2，k-1）+ … +f（28-k，k-1），因此f（i，k）的计算可以通过一个递归来实现，只要能求出g（k）和f（i，k），便可使用上述的解题思路对任何升序字符串进行求解。
1.2 程序源码
import java.io.*;
import java.util.Scanner;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Dictionary {
//将输入的字符串转化为字符数组
private char[] converse(String input){
if(input.length()<1||input.length()>6){
return null;
}
char[]chars=input.toCharArray();
for(int i=chars.length-1;i>0;i--){
if(chars[i]<chars[i-1]){
return null;
}
}
return chars;
}
//change方法用与将字符转化为对应的编号
private int change(char c){
return c-'a'+1;
}
//f(i,k)计算以编号为i的字母开头，长度为k的升序字符串个数private int f(int i,int k){
int sum=0;
if(k==1){
return 1;
}
for(int j=i+1;j<=28-k;j++){
sum+=f(j,k-1);
}
return sum;
}
//g(k)用于计算长度为k的字符串组合数
private int g(int k){
int sum=0;
for(int i=1;i<=27-k;i++){
sum+=f(i,k);
}
return sum;
}
//计算编号的主方法,参数为待求升序字符串
public int getOrder(String input){
int order=0;
char[] chars;
if((chars=converse(input))==null){
return -1;
}
int len=chars.length;
//求长度小于待求字符串的所有组合个数
for(int k=1;k<len;k++){
order+=g(k);
}
//求长度等于len，首字母小于待求字符串首字母的组合个数
for(int i=1;i<change(chars[0]);i++){
order+=f(i,len);
}
//求首字母为chars[0]的所有字符串个数
int temp=change(chars[0]),n,j;
for(n=1;n<len;n++){
for(j=temp+1;j<change(chars[n]);j++){
order+=f(j,len-n);
//求字母大于前一个字母小于当前字母，并且长度为当前字母之后的全部字母的字符串组合个数
}
temp=chars[n];
}
return order+1;
}
public static void main(String[]args){
System.out.println("实验一算法的分析基础");
System.out.print("\n");
System.out.println("题目：统计数字问题");
System.out.println("姓名：李勇学号：1007092105");
System.out.print("\n");
//计时开始的时候
long startTime = System.nanoTime();
Dictionary dr=new Dictionary();
int num = 0;
String input[] = null;
int order[];
try{
//打开指定路径下文件
FileReader in=new FileReader
("ENCODE.IN");
BufferedReader a= new BufferedReader(in);
num = Integer.parseInt(a.readLine());
input= new String[num+1];
for(int i=0;i<=num;i++){
input[i]=a.readLine();
}
a.close();
in.close();
order = new int[num];
for(int i = 0; i<num; i++)
order[i]=dr.getOrder(input[i]);
//输出文本到“OUTPUTx.txt”
FileWriter out=new FileWriter
("OUTPUT.txt");
BufferedWriter b=new BufferedWriter(out);
for(int i = 0;i<num;i++){
b.write(String.valueOf(order[i]).toCharArray());
System.out.print(String.valueOf(order[i]).toCharArray());
System.out.print("\n");
b.newLine();
}
b.close();
out.close();
//计时结束时候
long endTime = System.nanoTime();
System.out.println
("本次程序运行耗时 " + (endTime-startTime)/1000 + " us" );
SimpleDateFormat time = new SimpleDateFormat (" yyyy-MM-dd HH:mm:ss");//设置日期格式
System.out.println(time.format(new Date()));
}
catch(IOException e){ System.out.println(e); } }
}
1.3 实验结论（结果验证）
1.4 心得体会。
